001package org.hl7.fhir.r5.formats; 002 003 004// generated 005 006/* 007 * #%L 008 * org.hl7.fhir.r5 009 * %% 010 * Copyright (C) 2014 - 2019 Health Level 7 011 * %% 012 * Licensed under the Apache License, Version 2.0 (the \"License\"); 013 * you may not use this file except in compliance with the License. 014 * You may obtain a copy of the License at 015 * 016 * http://www.apache.org/licenses/LICENSE-2.0 017 * 018 * Unless required by applicable law or agreed to in writing, software 019 * distributed under the License is distributed on an \"AS IS\" BASIS, 020 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 021 * See the License for the specific language governing permissions and 022 * limitations under the License. 023 * #L% 024 */ 025 026/* 027 Copyright (c) 2011+, HL7, Inc. 028 All rights reserved. 029 030 Redistribution and use in source and binary forms, with or without modification, \ 031 are permitted provided that the following conditions are met: 032 033 * Redistributions of source code must retain the above copyright notice, this \ 034 list of conditions and the following disclaimer. 035 * Redistributions in binary form must reproduce the above copyright notice, \ 036 this list of conditions and the following disclaimer in the documentation \ 037 and/or other materials provided with the distribution. 038 * Neither the name of HL7 nor the names of its contributors may be used to 039 endorse or promote products derived from this software without specific 040 prior written permission. 041 042 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \ 043 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \ 044 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \ 045 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \ 046 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \ 047 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \ 048 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \ 049 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \ 050 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \ 051 POSSIBILITY OF SUCH DAMAGE. 052 */ 053 054// Generated on Tue, Dec 31, 2019 12:12+1100 for FHIR vcurrent 055 056 057 058import org.hl7.fhir.r5.model.*; 059import org.hl7.fhir.utilities.Utilities; 060import org.hl7.fhir.exceptions.FHIRFormatError; 061import org.hl7.fhir.exceptions.FHIRException; 062import org.hl7.fhir.r5.utils.formats.Turtle.Complex; 063import java.io.IOException; 064 065public class RdfParser extends RdfParserBase { 066 067 public RdfParser() { 068 super(); 069 } 070 071 public RdfParser(boolean allowUnknownContent) { 072 super(); 073 setAllowUnknownContent(allowUnknownContent); 074 } 075 076 private void composeEnum(Complex parent, String parentType, String name, Enumeration<? extends Enum> value, int index) { 077 if (value == null) 078 return; 079 Complex t = parent.predicate("fhir:"+parentType+"."+name); 080 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 081 composeElement(t, parentType, name, value, index); 082 decorateCode(t, value); 083 } 084 085 086 protected void composeDate(Complex parent, String parentType, String name, DateType 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 } 093 094 protected void composeDateTime(Complex parent, String parentType, String name, DateTimeType value, int index) { 095 if (value == null) 096 return; 097 Complex t = parent.predicate("fhir:"+parentType+"."+name); 098 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 099 composeElement(t, parentType, name, value, index); 100 } 101 102 protected void composeCode(Complex parent, String parentType, String name, CodeType value, int index) { 103 if (value == null) 104 return; 105 Complex t = parent.predicate("fhir:"+parentType+"."+name); 106 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 107 composeElement(t, parentType, name, value, index); 108 decorateCode(t, value); 109 } 110 111 protected void composeString(Complex parent, String parentType, String name, StringType value, int index) { 112 if (value == null) 113 return; 114 Complex t = parent.predicate("fhir:"+parentType+"."+name); 115 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 116 composeElement(t, parentType, name, value, index); 117 } 118 119 protected void composeInteger(Complex parent, String parentType, String name, IntegerType value, int index) { 120 if (value == null) 121 return; 122 Complex t = parent.predicate("fhir:"+parentType+"."+name); 123 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 124 composeElement(t, parentType, name, value, index); 125 } 126 127 protected void composeInteger64(Complex parent, String parentType, String name, Integer64Type value, int index) { 128 if (value == null) 129 return; 130 Complex t = parent.predicate("fhir:"+parentType+"."+name); 131 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 132 composeElement(t, parentType, name, value, index); 133 } 134 135 protected void composeOid(Complex parent, String parentType, String name, OidType value, int index) { 136 if (value == null) 137 return; 138 Complex t = parent.predicate("fhir:"+parentType+"."+name); 139 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 140 composeElement(t, parentType, name, value, index); 141 } 142 143 protected void composeCanonical(Complex parent, String parentType, String name, CanonicalType value, int index) { 144 if (value == null) 145 return; 146 Complex t = parent.predicate("fhir:"+parentType+"."+name); 147 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 148 composeElement(t, parentType, name, value, index); 149 } 150 151 protected void composeUri(Complex parent, String parentType, String name, UriType value, int index) { 152 if (value == null) 153 return; 154 Complex t = parent.predicate("fhir:"+parentType+"."+name); 155 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 156 composeElement(t, parentType, name, value, index); 157 } 158 159 protected void composeUuid(Complex parent, String parentType, String name, UuidType value, int index) { 160 if (value == null) 161 return; 162 Complex t = parent.predicate("fhir:"+parentType+"."+name); 163 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 164 composeElement(t, parentType, name, value, index); 165 } 166 167 protected void composeUrl(Complex parent, String parentType, String name, UrlType value, int index) { 168 if (value == null) 169 return; 170 Complex t = parent.predicate("fhir:"+parentType+"."+name); 171 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 172 composeElement(t, parentType, name, value, index); 173 } 174 175 protected void composeInstant(Complex parent, String parentType, String name, InstantType value, int index) { 176 if (value == null) 177 return; 178 Complex t = parent.predicate("fhir:"+parentType+"."+name); 179 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 180 composeElement(t, parentType, name, value, index); 181 } 182 183 protected void composeBoolean(Complex parent, String parentType, String name, BooleanType value, int index) { 184 if (value == null) 185 return; 186 Complex t = parent.predicate("fhir:"+parentType+"."+name); 187 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 188 composeElement(t, parentType, name, value, index); 189 } 190 191 protected void composeBase64Binary(Complex parent, String parentType, String name, Base64BinaryType value, int index) { 192 if (value == null) 193 return; 194 Complex t = parent.predicate("fhir:"+parentType+"."+name); 195 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 196 composeElement(t, parentType, name, value, index); 197 } 198 199 protected void composeUnsignedInt(Complex parent, String parentType, String name, UnsignedIntType value, int index) { 200 if (value == null) 201 return; 202 Complex t = parent.predicate("fhir:"+parentType+"."+name); 203 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 204 composeElement(t, parentType, name, value, index); 205 } 206 207 protected void composeMarkdown(Complex parent, String parentType, String name, MarkdownType value, int index) { 208 if (value == null) 209 return; 210 Complex t = parent.predicate("fhir:"+parentType+"."+name); 211 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 212 composeElement(t, parentType, name, value, index); 213 } 214 215 protected void composeTime(Complex parent, String parentType, String name, TimeType value, int index) { 216 if (value == null) 217 return; 218 Complex t = parent.predicate("fhir:"+parentType+"."+name); 219 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 220 composeElement(t, parentType, name, value, index); 221 } 222 223 protected void composeId(Complex parent, String parentType, String name, IdType value, int index) { 224 if (value == null) 225 return; 226 Complex t = parent.predicate("fhir:"+parentType+"."+name); 227 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 228 composeElement(t, parentType, name, value, index); 229 } 230 231 protected void composePositiveInt(Complex parent, String parentType, String name, PositiveIntType value, int index) { 232 if (value == null) 233 return; 234 Complex t = parent.predicate("fhir:"+parentType+"."+name); 235 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 236 composeElement(t, parentType, name, value, index); 237 } 238 239 protected void composeDecimal(Complex parent, String parentType, String name, DecimalType value, int index) { 240 if (value == null) 241 return; 242 Complex t = parent.predicate("fhir:"+parentType+"."+name); 243 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 244 composeElement(t, parentType, name, value, index); 245 } 246 247 protected void composeBackboneElement(Complex t, String parentType, String name, BackboneElement element, int index) { 248 composeElement(t, parentType, name, element, index); 249 for (int i = 0; i < element.getModifierExtension().size(); i++) { 250 composeExtension(t, "BackboneElement", "modifierExtension", element.getModifierExtension().get(i), i); 251 } 252 } 253 254 protected void composeBackboneType(Complex t, String parentType, String name, BackboneType element, int index) { 255 composeDataType(t, parentType, name, element, index); 256 for (int i = 0; i < element.getModifierExtension().size(); i++) { 257 composeExtension(t, "BackboneType", "modifierExtension", element.getModifierExtension().get(i), i); 258 } 259 } 260 261 protected void composeDataType(Complex t, String parentType, String name, DataType element, int index) { 262 composeElement(t, parentType, name, element, index); 263 } 264 265 protected void composeElement(Complex t, String parentType, String name, Element element, int index) { 266 composeBase(t, parentType, name, element, index); 267 if (element.hasIdElement()) { 268 composeString(t, "Element", "id", element.getIdElement(), -1); 269 } 270 for (int i = 0; i < element.getExtension().size(); i++) { 271 composeExtension(t, "Element", "extension", element.getExtension().get(i), i); 272 } 273 } 274 275 protected void composeAddress(Complex parent, String parentType, String name, Address element, int index) { 276 if (element == null) 277 return; 278 Complex t; 279 if (Utilities.noString(parentType)) 280 t = parent; 281 else { 282 t = parent.predicate("fhir:"+parentType+'.'+name); 283 } 284 composeDataType(t, "Address", name, element, index); 285 if (element.hasUseElement()) { 286 composeEnum(t, "Address", "use", element.getUseElement(), -1); 287 } 288 if (element.hasTypeElement()) { 289 composeEnum(t, "Address", "type", element.getTypeElement(), -1); 290 } 291 if (element.hasTextElement()) { 292 composeString(t, "Address", "text", element.getTextElement(), -1); 293 } 294 for (int i = 0; i < element.getLine().size(); i++) { 295 composeString(t, "Address", "line", element.getLine().get(i), i); 296 } 297 if (element.hasCityElement()) { 298 composeString(t, "Address", "city", element.getCityElement(), -1); 299 } 300 if (element.hasDistrictElement()) { 301 composeString(t, "Address", "district", element.getDistrictElement(), -1); 302 } 303 if (element.hasStateElement()) { 304 composeString(t, "Address", "state", element.getStateElement(), -1); 305 } 306 if (element.hasPostalCodeElement()) { 307 composeString(t, "Address", "postalCode", element.getPostalCodeElement(), -1); 308 } 309 if (element.hasCountryElement()) { 310 composeString(t, "Address", "country", element.getCountryElement(), -1); 311 } 312 if (element.hasPeriod()) { 313 composePeriod(t, "Address", "period", element.getPeriod(), -1); 314 } 315 } 316 317 protected void composeAge(Complex parent, String parentType, String name, Age element, int index) { 318 if (element == null) 319 return; 320 Complex t; 321 if (Utilities.noString(parentType)) 322 t = parent; 323 else { 324 t = parent.predicate("fhir:"+parentType+'.'+name); 325 } 326 composeQuantity(t, "Age", name, element, index); 327 } 328 329 protected void composeAnnotation(Complex parent, String parentType, String name, Annotation element, int index) { 330 if (element == null) 331 return; 332 Complex t; 333 if (Utilities.noString(parentType)) 334 t = parent; 335 else { 336 t = parent.predicate("fhir:"+parentType+'.'+name); 337 } 338 composeDataType(t, "Annotation", name, element, index); 339 if (element.hasAuthor()) { 340 composeType(t, "Annotation", "author", element.getAuthor(), -1); 341 } 342 if (element.hasTimeElement()) { 343 composeDateTime(t, "Annotation", "time", element.getTimeElement(), -1); 344 } 345 if (element.hasTextElement()) { 346 composeMarkdown(t, "Annotation", "text", element.getTextElement(), -1); 347 } 348 } 349 350 protected void composeAttachment(Complex parent, String parentType, String name, Attachment element, int index) { 351 if (element == null) 352 return; 353 Complex t; 354 if (Utilities.noString(parentType)) 355 t = parent; 356 else { 357 t = parent.predicate("fhir:"+parentType+'.'+name); 358 } 359 composeDataType(t, "Attachment", name, element, index); 360 if (element.hasContentTypeElement()) { 361 composeCode(t, "Attachment", "contentType", element.getContentTypeElement(), -1); 362 } 363 if (element.hasLanguageElement()) { 364 composeCode(t, "Attachment", "language", element.getLanguageElement(), -1); 365 } 366 if (element.hasDataElement()) { 367 composeBase64Binary(t, "Attachment", "data", element.getDataElement(), -1); 368 } 369 if (element.hasUrlElement()) { 370 composeUrl(t, "Attachment", "url", element.getUrlElement(), -1); 371 } 372 if (element.hasSizeElement()) { 373 composeInteger64(t, "Attachment", "size", element.getSizeElement(), -1); 374 } 375 if (element.hasHashElement()) { 376 composeBase64Binary(t, "Attachment", "hash", element.getHashElement(), -1); 377 } 378 if (element.hasTitleElement()) { 379 composeString(t, "Attachment", "title", element.getTitleElement(), -1); 380 } 381 if (element.hasCreationElement()) { 382 composeDateTime(t, "Attachment", "creation", element.getCreationElement(), -1); 383 } 384 if (element.hasHeightElement()) { 385 composePositiveInt(t, "Attachment", "height", element.getHeightElement(), -1); 386 } 387 if (element.hasWidthElement()) { 388 composePositiveInt(t, "Attachment", "width", element.getWidthElement(), -1); 389 } 390 if (element.hasFramesElement()) { 391 composePositiveInt(t, "Attachment", "frames", element.getFramesElement(), -1); 392 } 393 if (element.hasDurationElement()) { 394 composeDecimal(t, "Attachment", "duration", element.getDurationElement(), -1); 395 } 396 if (element.hasPagesElement()) { 397 composePositiveInt(t, "Attachment", "pages", element.getPagesElement(), -1); 398 } 399 } 400 401 protected void composeCodeableConcept(Complex parent, String parentType, String name, CodeableConcept element, int index) { 402 if (element == null) 403 return; 404 Complex t; 405 if (Utilities.noString(parentType)) 406 t = parent; 407 else { 408 t = parent.predicate("fhir:"+parentType+'.'+name); 409 } 410 composeDataType(t, "CodeableConcept", name, element, index); 411 decorateCodeableConcept(t, element); 412 for (int i = 0; i < element.getCoding().size(); i++) { 413 composeCoding(t, "CodeableConcept", "coding", element.getCoding().get(i), i); 414 } 415 if (element.hasTextElement()) { 416 composeString(t, "CodeableConcept", "text", element.getTextElement(), -1); 417 } 418 } 419 420 protected void composeCodeableReference(Complex parent, String parentType, String name, CodeableReference element, int index) { 421 if (element == null) 422 return; 423 Complex t; 424 if (Utilities.noString(parentType)) 425 t = parent; 426 else { 427 t = parent.predicate("fhir:"+parentType+'.'+name); 428 } 429 composeDataType(t, "CodeableReference", name, element, index); 430 if (element.hasConcept()) { 431 composeCodeableConcept(t, "CodeableReference", "concept", element.getConcept(), -1); 432 } 433 if (element.hasReference()) { 434 composeReference(t, "CodeableReference", "reference", element.getReference(), -1); 435 } 436 } 437 438 protected void composeCoding(Complex parent, String parentType, String name, Coding element, int index) { 439 if (element == null) 440 return; 441 Complex t; 442 if (Utilities.noString(parentType)) 443 t = parent; 444 else { 445 t = parent.predicate("fhir:"+parentType+'.'+name); 446 } 447 composeDataType(t, "Coding", name, element, index); 448 decorateCoding(t, element); 449 if (element.hasSystemElement()) { 450 composeUri(t, "Coding", "system", element.getSystemElement(), -1); 451 } 452 if (element.hasVersionElement()) { 453 composeString(t, "Coding", "version", element.getVersionElement(), -1); 454 } 455 if (element.hasCodeElement()) { 456 composeCode(t, "Coding", "code", element.getCodeElement(), -1); 457 } 458 if (element.hasDisplayElement()) { 459 composeString(t, "Coding", "display", element.getDisplayElement(), -1); 460 } 461 if (element.hasUserSelectedElement()) { 462 composeBoolean(t, "Coding", "userSelected", element.getUserSelectedElement(), -1); 463 } 464 } 465 466 protected void composeContactDetail(Complex parent, String parentType, String name, ContactDetail element, int index) { 467 if (element == null) 468 return; 469 Complex t; 470 if (Utilities.noString(parentType)) 471 t = parent; 472 else { 473 t = parent.predicate("fhir:"+parentType+'.'+name); 474 } 475 composeDataType(t, "ContactDetail", name, element, index); 476 if (element.hasNameElement()) { 477 composeString(t, "ContactDetail", "name", element.getNameElement(), -1); 478 } 479 for (int i = 0; i < element.getTelecom().size(); i++) { 480 composeContactPoint(t, "ContactDetail", "telecom", element.getTelecom().get(i), i); 481 } 482 } 483 484 protected void composeContactPoint(Complex parent, String parentType, String name, ContactPoint element, int index) { 485 if (element == null) 486 return; 487 Complex t; 488 if (Utilities.noString(parentType)) 489 t = parent; 490 else { 491 t = parent.predicate("fhir:"+parentType+'.'+name); 492 } 493 composeDataType(t, "ContactPoint", name, element, index); 494 if (element.hasSystemElement()) { 495 composeEnum(t, "ContactPoint", "system", element.getSystemElement(), -1); 496 } 497 if (element.hasValueElement()) { 498 composeString(t, "ContactPoint", "value", element.getValueElement(), -1); 499 } 500 if (element.hasUseElement()) { 501 composeEnum(t, "ContactPoint", "use", element.getUseElement(), -1); 502 } 503 if (element.hasRankElement()) { 504 composePositiveInt(t, "ContactPoint", "rank", element.getRankElement(), -1); 505 } 506 if (element.hasPeriod()) { 507 composePeriod(t, "ContactPoint", "period", element.getPeriod(), -1); 508 } 509 } 510 511 protected void composeContributor(Complex parent, String parentType, String name, Contributor element, int index) { 512 if (element == null) 513 return; 514 Complex t; 515 if (Utilities.noString(parentType)) 516 t = parent; 517 else { 518 t = parent.predicate("fhir:"+parentType+'.'+name); 519 } 520 composeDataType(t, "Contributor", name, element, index); 521 if (element.hasTypeElement()) { 522 composeEnum(t, "Contributor", "type", element.getTypeElement(), -1); 523 } 524 if (element.hasNameElement()) { 525 composeString(t, "Contributor", "name", element.getNameElement(), -1); 526 } 527 for (int i = 0; i < element.getContact().size(); i++) { 528 composeContactDetail(t, "Contributor", "contact", element.getContact().get(i), i); 529 } 530 } 531 532 protected void composeCount(Complex parent, String parentType, String name, Count element, int index) { 533 if (element == null) 534 return; 535 Complex t; 536 if (Utilities.noString(parentType)) 537 t = parent; 538 else { 539 t = parent.predicate("fhir:"+parentType+'.'+name); 540 } 541 composeQuantity(t, "Count", name, element, index); 542 } 543 544 protected void composeDataRequirement(Complex parent, String parentType, String name, DataRequirement element, int index) { 545 if (element == null) 546 return; 547 Complex t; 548 if (Utilities.noString(parentType)) 549 t = parent; 550 else { 551 t = parent.predicate("fhir:"+parentType+'.'+name); 552 } 553 composeDataType(t, "DataRequirement", name, element, index); 554 if (element.hasTypeElement()) { 555 composeEnum(t, "DataRequirement", "type", element.getTypeElement(), -1); 556 } 557 for (int i = 0; i < element.getProfile().size(); i++) { 558 composeCanonical(t, "DataRequirement", "profile", element.getProfile().get(i), i); 559 } 560 if (element.hasSubject()) { 561 composeType(t, "DataRequirement", "subject", element.getSubject(), -1); 562 } 563 for (int i = 0; i < element.getMustSupport().size(); i++) { 564 composeString(t, "DataRequirement", "mustSupport", element.getMustSupport().get(i), i); 565 } 566 for (int i = 0; i < element.getCodeFilter().size(); i++) { 567 composeDataRequirementCodeFilterComponent(t, "DataRequirement", "codeFilter", element.getCodeFilter().get(i), i); 568 } 569 for (int i = 0; i < element.getDateFilter().size(); i++) { 570 composeDataRequirementDateFilterComponent(t, "DataRequirement", "dateFilter", element.getDateFilter().get(i), i); 571 } 572 if (element.hasLimitElement()) { 573 composePositiveInt(t, "DataRequirement", "limit", element.getLimitElement(), -1); 574 } 575 for (int i = 0; i < element.getSort().size(); i++) { 576 composeDataRequirementSortComponent(t, "DataRequirement", "sort", element.getSort().get(i), i); 577 } 578 } 579 580 protected void composeDataRequirementCodeFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementCodeFilterComponent element, int index) { 581 if (element == null) 582 return; 583 Complex t; 584 if (Utilities.noString(parentType)) 585 t = parent; 586 else { 587 t = parent.predicate("fhir:"+parentType+'.'+name); 588 } 589 composeElement(t, "codeFilter", name, element, index); 590 if (element.hasPathElement()) { 591 composeString(t, "DataRequirementCodeFilterComponent", "path", element.getPathElement(), -1); 592 } 593 if (element.hasSearchParamElement()) { 594 composeString(t, "DataRequirementCodeFilterComponent", "searchParam", element.getSearchParamElement(), -1); 595 } 596 if (element.hasValueSetElement()) { 597 composeCanonical(t, "DataRequirementCodeFilterComponent", "valueSet", element.getValueSetElement(), -1); 598 } 599 for (int i = 0; i < element.getCode().size(); i++) { 600 composeCoding(t, "DataRequirementCodeFilterComponent", "code", element.getCode().get(i), i); 601 } 602 } 603 604 protected void composeDataRequirementDateFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementDateFilterComponent element, int index) { 605 if (element == null) 606 return; 607 Complex t; 608 if (Utilities.noString(parentType)) 609 t = parent; 610 else { 611 t = parent.predicate("fhir:"+parentType+'.'+name); 612 } 613 composeElement(t, "dateFilter", name, element, index); 614 if (element.hasPathElement()) { 615 composeString(t, "DataRequirementDateFilterComponent", "path", element.getPathElement(), -1); 616 } 617 if (element.hasSearchParamElement()) { 618 composeString(t, "DataRequirementDateFilterComponent", "searchParam", element.getSearchParamElement(), -1); 619 } 620 if (element.hasValue()) { 621 composeType(t, "DataRequirementDateFilterComponent", "value", element.getValue(), -1); 622 } 623 } 624 625 protected void composeDataRequirementSortComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementSortComponent element, int index) { 626 if (element == null) 627 return; 628 Complex t; 629 if (Utilities.noString(parentType)) 630 t = parent; 631 else { 632 t = parent.predicate("fhir:"+parentType+'.'+name); 633 } 634 composeElement(t, "sort", name, element, index); 635 if (element.hasPathElement()) { 636 composeString(t, "DataRequirementSortComponent", "path", element.getPathElement(), -1); 637 } 638 if (element.hasDirectionElement()) { 639 composeEnum(t, "DataRequirementSortComponent", "direction", element.getDirectionElement(), -1); 640 } 641 } 642 643 protected void composeDistance(Complex parent, String parentType, String name, Distance 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 composeQuantity(t, "Distance", name, element, index); 653 } 654 655 protected void composeDosage(Complex parent, String parentType, String name, Dosage element, int index) { 656 if (element == null) 657 return; 658 Complex t; 659 if (Utilities.noString(parentType)) 660 t = parent; 661 else { 662 t = parent.predicate("fhir:"+parentType+'.'+name); 663 } 664 composeBackboneType(t, "Dosage", name, element, index); 665 if (element.hasSequenceElement()) { 666 composeInteger(t, "Dosage", "sequence", element.getSequenceElement(), -1); 667 } 668 if (element.hasTextElement()) { 669 composeString(t, "Dosage", "text", element.getTextElement(), -1); 670 } 671 for (int i = 0; i < element.getAdditionalInstruction().size(); i++) { 672 composeCodeableConcept(t, "Dosage", "additionalInstruction", element.getAdditionalInstruction().get(i), i); 673 } 674 if (element.hasPatientInstructionElement()) { 675 composeString(t, "Dosage", "patientInstruction", element.getPatientInstructionElement(), -1); 676 } 677 if (element.hasTiming()) { 678 composeTiming(t, "Dosage", "timing", element.getTiming(), -1); 679 } 680 if (element.hasAsNeeded()) { 681 composeType(t, "Dosage", "asNeeded", element.getAsNeeded(), -1); 682 } 683 if (element.hasSite()) { 684 composeCodeableConcept(t, "Dosage", "site", element.getSite(), -1); 685 } 686 if (element.hasRoute()) { 687 composeCodeableConcept(t, "Dosage", "route", element.getRoute(), -1); 688 } 689 if (element.hasMethod()) { 690 composeCodeableConcept(t, "Dosage", "method", element.getMethod(), -1); 691 } 692 for (int i = 0; i < element.getDoseAndRate().size(); i++) { 693 composeDosageDoseAndRateComponent(t, "Dosage", "doseAndRate", element.getDoseAndRate().get(i), i); 694 } 695 if (element.hasMaxDosePerPeriod()) { 696 composeRatio(t, "Dosage", "maxDosePerPeriod", element.getMaxDosePerPeriod(), -1); 697 } 698 if (element.hasMaxDosePerAdministration()) { 699 composeQuantity(t, "Dosage", "maxDosePerAdministration", element.getMaxDosePerAdministration(), -1); 700 } 701 if (element.hasMaxDosePerLifetime()) { 702 composeQuantity(t, "Dosage", "maxDosePerLifetime", element.getMaxDosePerLifetime(), -1); 703 } 704 } 705 706 protected void composeDosageDoseAndRateComponent(Complex parent, String parentType, String name, Dosage.DosageDoseAndRateComponent element, int index) { 707 if (element == null) 708 return; 709 Complex t; 710 if (Utilities.noString(parentType)) 711 t = parent; 712 else { 713 t = parent.predicate("fhir:"+parentType+'.'+name); 714 } 715 composeElement(t, "doseAndRate", name, element, index); 716 if (element.hasType()) { 717 composeCodeableConcept(t, "DosageDoseAndRateComponent", "type", element.getType(), -1); 718 } 719 if (element.hasDose()) { 720 composeType(t, "DosageDoseAndRateComponent", "dose", element.getDose(), -1); 721 } 722 if (element.hasRate()) { 723 composeType(t, "DosageDoseAndRateComponent", "rate", element.getRate(), -1); 724 } 725 } 726 727 protected void composeDuration(Complex parent, String parentType, String name, Duration element, int index) { 728 if (element == null) 729 return; 730 Complex t; 731 if (Utilities.noString(parentType)) 732 t = parent; 733 else { 734 t = parent.predicate("fhir:"+parentType+'.'+name); 735 } 736 composeQuantity(t, "Duration", name, element, index); 737 } 738 739 protected void composeElementDefinition(Complex parent, String parentType, String name, ElementDefinition element, int index) { 740 if (element == null) 741 return; 742 Complex t; 743 if (Utilities.noString(parentType)) 744 t = parent; 745 else { 746 t = parent.predicate("fhir:"+parentType+'.'+name); 747 } 748 composeBackboneType(t, "ElementDefinition", name, element, index); 749 if (element.hasPathElement()) { 750 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 751 } 752 for (int i = 0; i < element.getRepresentation().size(); i++) { 753 composeEnum(t, "ElementDefinition", "representation", element.getRepresentation().get(i), i); 754 } 755 if (element.hasSliceNameElement()) { 756 composeString(t, "ElementDefinition", "sliceName", element.getSliceNameElement(), -1); 757 } 758 if (element.hasSliceIsConstrainingElement()) { 759 composeBoolean(t, "ElementDefinition", "sliceIsConstraining", element.getSliceIsConstrainingElement(), -1); 760 } 761 if (element.hasLabelElement()) { 762 composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1); 763 } 764 for (int i = 0; i < element.getCode().size(); i++) { 765 composeCoding(t, "ElementDefinition", "code", element.getCode().get(i), i); 766 } 767 if (element.hasSlicing()) { 768 composeElementDefinitionSlicingComponent(t, "ElementDefinition", "slicing", element.getSlicing(), -1); 769 } 770 if (element.hasShortElement()) { 771 composeString(t, "ElementDefinition", "short", element.getShortElement(), -1); 772 } 773 if (element.hasDefinitionElement()) { 774 composeMarkdown(t, "ElementDefinition", "definition", element.getDefinitionElement(), -1); 775 } 776 if (element.hasCommentElement()) { 777 composeMarkdown(t, "ElementDefinition", "comment", element.getCommentElement(), -1); 778 } 779 if (element.hasRequirementsElement()) { 780 composeMarkdown(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1); 781 } 782 for (int i = 0; i < element.getAlias().size(); i++) { 783 composeString(t, "ElementDefinition", "alias", element.getAlias().get(i), i); 784 } 785 if (element.hasMinElement()) { 786 composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1); 787 } 788 if (element.hasMaxElement()) { 789 composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1); 790 } 791 if (element.hasBase()) { 792 composeElementDefinitionBaseComponent(t, "ElementDefinition", "base", element.getBase(), -1); 793 } 794 if (element.hasContentReferenceElement()) { 795 composeUri(t, "ElementDefinition", "contentReference", element.getContentReferenceElement(), -1); 796 } 797 for (int i = 0; i < element.getType().size(); i++) { 798 composeElementDefinitionTypeRefComponent(t, "ElementDefinition", "type", element.getType().get(i), i); 799 } 800 if (element.hasDefaultValue()) { 801 composeType(t, "ElementDefinition", "defaultValue", element.getDefaultValue(), -1); 802 } 803 if (element.hasMeaningWhenMissingElement()) { 804 composeMarkdown(t, "ElementDefinition", "meaningWhenMissing", element.getMeaningWhenMissingElement(), -1); 805 } 806 if (element.hasOrderMeaningElement()) { 807 composeString(t, "ElementDefinition", "orderMeaning", element.getOrderMeaningElement(), -1); 808 } 809 if (element.hasFixed()) { 810 composeType(t, "ElementDefinition", "fixed", element.getFixed(), -1); 811 } 812 if (element.hasPattern()) { 813 composeType(t, "ElementDefinition", "pattern", element.getPattern(), -1); 814 } 815 for (int i = 0; i < element.getExample().size(); i++) { 816 composeElementDefinitionExampleComponent(t, "ElementDefinition", "example", element.getExample().get(i), i); 817 } 818 if (element.hasMinValue()) { 819 composeType(t, "ElementDefinition", "minValue", element.getMinValue(), -1); 820 } 821 if (element.hasMaxValue()) { 822 composeType(t, "ElementDefinition", "maxValue", element.getMaxValue(), -1); 823 } 824 if (element.hasMaxLengthElement()) { 825 composeInteger(t, "ElementDefinition", "maxLength", element.getMaxLengthElement(), -1); 826 } 827 for (int i = 0; i < element.getCondition().size(); i++) { 828 composeId(t, "ElementDefinition", "condition", element.getCondition().get(i), i); 829 } 830 for (int i = 0; i < element.getConstraint().size(); i++) { 831 composeElementDefinitionConstraintComponent(t, "ElementDefinition", "constraint", element.getConstraint().get(i), i); 832 } 833 if (element.hasMustSupportElement()) { 834 composeBoolean(t, "ElementDefinition", "mustSupport", element.getMustSupportElement(), -1); 835 } 836 if (element.hasIsModifierElement()) { 837 composeBoolean(t, "ElementDefinition", "isModifier", element.getIsModifierElement(), -1); 838 } 839 if (element.hasIsModifierReasonElement()) { 840 composeString(t, "ElementDefinition", "isModifierReason", element.getIsModifierReasonElement(), -1); 841 } 842 if (element.hasIsSummaryElement()) { 843 composeBoolean(t, "ElementDefinition", "isSummary", element.getIsSummaryElement(), -1); 844 } 845 if (element.hasBinding()) { 846 composeElementDefinitionBindingComponent(t, "ElementDefinition", "binding", element.getBinding(), -1); 847 } 848 for (int i = 0; i < element.getMapping().size(); i++) { 849 composeElementDefinitionMappingComponent(t, "ElementDefinition", "mapping", element.getMapping().get(i), i); 850 } 851 } 852 853 protected void composeElementDefinitionSlicingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingComponent element, int index) { 854 if (element == null) 855 return; 856 Complex t; 857 if (Utilities.noString(parentType)) 858 t = parent; 859 else { 860 t = parent.predicate("fhir:"+parentType+'.'+name); 861 } 862 composeElement(t, "slicing", name, element, index); 863 for (int i = 0; i < element.getDiscriminator().size(); i++) { 864 composeElementDefinitionSlicingDiscriminatorComponent(t, "ElementDefinitionSlicingComponent", "discriminator", element.getDiscriminator().get(i), i); 865 } 866 if (element.hasDescriptionElement()) { 867 composeString(t, "ElementDefinitionSlicingComponent", "description", element.getDescriptionElement(), -1); 868 } 869 if (element.hasOrderedElement()) { 870 composeBoolean(t, "ElementDefinitionSlicingComponent", "ordered", element.getOrderedElement(), -1); 871 } 872 if (element.hasRulesElement()) { 873 composeEnum(t, "ElementDefinitionSlicingComponent", "rules", element.getRulesElement(), -1); 874 } 875 } 876 877 protected void composeElementDefinitionSlicingDiscriminatorComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent element, int index) { 878 if (element == null) 879 return; 880 Complex t; 881 if (Utilities.noString(parentType)) 882 t = parent; 883 else { 884 t = parent.predicate("fhir:"+parentType+'.'+name); 885 } 886 composeElement(t, "discriminator", name, element, index); 887 if (element.hasTypeElement()) { 888 composeEnum(t, "ElementDefinitionSlicingDiscriminatorComponent", "type", element.getTypeElement(), -1); 889 } 890 if (element.hasPathElement()) { 891 composeString(t, "ElementDefinitionSlicingDiscriminatorComponent", "path", element.getPathElement(), -1); 892 } 893 } 894 895 protected void composeElementDefinitionBaseComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBaseComponent element, int index) { 896 if (element == null) 897 return; 898 Complex t; 899 if (Utilities.noString(parentType)) 900 t = parent; 901 else { 902 t = parent.predicate("fhir:"+parentType+'.'+name); 903 } 904 composeElement(t, "base", name, element, index); 905 if (element.hasPathElement()) { 906 composeString(t, "ElementDefinitionBaseComponent", "path", element.getPathElement(), -1); 907 } 908 if (element.hasMinElement()) { 909 composeUnsignedInt(t, "ElementDefinitionBaseComponent", "min", element.getMinElement(), -1); 910 } 911 if (element.hasMaxElement()) { 912 composeString(t, "ElementDefinitionBaseComponent", "max", element.getMaxElement(), -1); 913 } 914 } 915 916 protected void composeElementDefinitionTypeRefComponent(Complex parent, String parentType, String name, ElementDefinition.TypeRefComponent element, int index) { 917 if (element == null) 918 return; 919 Complex t; 920 if (Utilities.noString(parentType)) 921 t = parent; 922 else { 923 t = parent.predicate("fhir:"+parentType+'.'+name); 924 } 925 composeElement(t, "type", name, element, index); 926 if (element.hasCodeElement()) { 927 composeUri(t, "TypeRefComponent", "code", element.getCodeElement(), -1); 928 } 929 for (int i = 0; i < element.getProfile().size(); i++) { 930 composeCanonical(t, "TypeRefComponent", "profile", element.getProfile().get(i), i); 931 } 932 for (int i = 0; i < element.getTargetProfile().size(); i++) { 933 composeCanonical(t, "TypeRefComponent", "targetProfile", element.getTargetProfile().get(i), i); 934 } 935 for (int i = 0; i < element.getAggregation().size(); i++) { 936 composeEnum(t, "TypeRefComponent", "aggregation", element.getAggregation().get(i), i); 937 } 938 if (element.hasVersioningElement()) { 939 composeEnum(t, "TypeRefComponent", "versioning", element.getVersioningElement(), -1); 940 } 941 } 942 943 protected void composeElementDefinitionExampleComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionExampleComponent element, int index) { 944 if (element == null) 945 return; 946 Complex t; 947 if (Utilities.noString(parentType)) 948 t = parent; 949 else { 950 t = parent.predicate("fhir:"+parentType+'.'+name); 951 } 952 composeElement(t, "example", name, element, index); 953 if (element.hasLabelElement()) { 954 composeString(t, "ElementDefinitionExampleComponent", "label", element.getLabelElement(), -1); 955 } 956 if (element.hasValue()) { 957 composeType(t, "ElementDefinitionExampleComponent", "value", element.getValue(), -1); 958 } 959 } 960 961 protected void composeElementDefinitionConstraintComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionConstraintComponent element, int index) { 962 if (element == null) 963 return; 964 Complex t; 965 if (Utilities.noString(parentType)) 966 t = parent; 967 else { 968 t = parent.predicate("fhir:"+parentType+'.'+name); 969 } 970 composeElement(t, "constraint", name, element, index); 971 if (element.hasKeyElement()) { 972 composeId(t, "ElementDefinitionConstraintComponent", "key", element.getKeyElement(), -1); 973 } 974 if (element.hasRequirementsElement()) { 975 composeString(t, "ElementDefinitionConstraintComponent", "requirements", element.getRequirementsElement(), -1); 976 } 977 if (element.hasSeverityElement()) { 978 composeEnum(t, "ElementDefinitionConstraintComponent", "severity", element.getSeverityElement(), -1); 979 } 980 if (element.hasHumanElement()) { 981 composeString(t, "ElementDefinitionConstraintComponent", "human", element.getHumanElement(), -1); 982 } 983 if (element.hasExpressionElement()) { 984 composeString(t, "ElementDefinitionConstraintComponent", "expression", element.getExpressionElement(), -1); 985 } 986 if (element.hasXpathElement()) { 987 composeString(t, "ElementDefinitionConstraintComponent", "xpath", element.getXpathElement(), -1); 988 } 989 if (element.hasSourceElement()) { 990 composeCanonical(t, "ElementDefinitionConstraintComponent", "source", element.getSourceElement(), -1); 991 } 992 } 993 994 protected void composeElementDefinitionBindingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingComponent element, int index) { 995 if (element == null) 996 return; 997 Complex t; 998 if (Utilities.noString(parentType)) 999 t = parent; 1000 else { 1001 t = parent.predicate("fhir:"+parentType+'.'+name); 1002 } 1003 composeElement(t, "binding", name, element, index); 1004 if (element.hasStrengthElement()) { 1005 composeEnum(t, "ElementDefinitionBindingComponent", "strength", element.getStrengthElement(), -1); 1006 } 1007 if (element.hasDescriptionElement()) { 1008 composeString(t, "ElementDefinitionBindingComponent", "description", element.getDescriptionElement(), -1); 1009 } 1010 if (element.hasValueSetElement()) { 1011 composeCanonical(t, "ElementDefinitionBindingComponent", "valueSet", element.getValueSetElement(), -1); 1012 } 1013 } 1014 1015 protected void composeElementDefinitionMappingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionMappingComponent element, int index) { 1016 if (element == null) 1017 return; 1018 Complex t; 1019 if (Utilities.noString(parentType)) 1020 t = parent; 1021 else { 1022 t = parent.predicate("fhir:"+parentType+'.'+name); 1023 } 1024 composeElement(t, "mapping", name, element, index); 1025 if (element.hasIdentityElement()) { 1026 composeId(t, "ElementDefinitionMappingComponent", "identity", element.getIdentityElement(), -1); 1027 } 1028 if (element.hasLanguageElement()) { 1029 composeCode(t, "ElementDefinitionMappingComponent", "language", element.getLanguageElement(), -1); 1030 } 1031 if (element.hasMapElement()) { 1032 composeString(t, "ElementDefinitionMappingComponent", "map", element.getMapElement(), -1); 1033 } 1034 if (element.hasCommentElement()) { 1035 composeString(t, "ElementDefinitionMappingComponent", "comment", element.getCommentElement(), -1); 1036 } 1037 } 1038 1039 protected void composeExpression(Complex parent, String parentType, String name, Expression element, int index) { 1040 if (element == null) 1041 return; 1042 Complex t; 1043 if (Utilities.noString(parentType)) 1044 t = parent; 1045 else { 1046 t = parent.predicate("fhir:"+parentType+'.'+name); 1047 } 1048 composeDataType(t, "Expression", name, element, index); 1049 if (element.hasDescriptionElement()) { 1050 composeString(t, "Expression", "description", element.getDescriptionElement(), -1); 1051 } 1052 if (element.hasNameElement()) { 1053 composeId(t, "Expression", "name", element.getNameElement(), -1); 1054 } 1055 if (element.hasLanguageElement()) { 1056 composeCode(t, "Expression", "language", element.getLanguageElement(), -1); 1057 } 1058 if (element.hasExpressionElement()) { 1059 composeString(t, "Expression", "expression", element.getExpressionElement(), -1); 1060 } 1061 if (element.hasReferenceElement()) { 1062 composeUri(t, "Expression", "reference", element.getReferenceElement(), -1); 1063 } 1064 } 1065 1066 protected void composeExtension(Complex parent, String parentType, String name, Extension element, int index) { 1067 if (element == null) 1068 return; 1069 Complex t; 1070 if (Utilities.noString(parentType)) 1071 t = parent; 1072 else { 1073 t = parent.predicate("fhir:"+parentType+'.'+name); 1074 } 1075 composeDataType(t, "Extension", name, element, index); 1076 if (element.hasUrlElement()) { 1077 composeUri(t, "Extension", "url", element.getUrlElement(), -1); 1078 } 1079 if (element.hasValue()) { 1080 composeType(t, "Extension", "value", element.getValue(), -1); 1081 } 1082 } 1083 1084 protected void composeHumanName(Complex parent, String parentType, String name, HumanName element, int index) { 1085 if (element == null) 1086 return; 1087 Complex t; 1088 if (Utilities.noString(parentType)) 1089 t = parent; 1090 else { 1091 t = parent.predicate("fhir:"+parentType+'.'+name); 1092 } 1093 composeDataType(t, "HumanName", name, element, index); 1094 if (element.hasUseElement()) { 1095 composeEnum(t, "HumanName", "use", element.getUseElement(), -1); 1096 } 1097 if (element.hasTextElement()) { 1098 composeString(t, "HumanName", "text", element.getTextElement(), -1); 1099 } 1100 if (element.hasFamilyElement()) { 1101 composeString(t, "HumanName", "family", element.getFamilyElement(), -1); 1102 } 1103 for (int i = 0; i < element.getGiven().size(); i++) { 1104 composeString(t, "HumanName", "given", element.getGiven().get(i), i); 1105 } 1106 for (int i = 0; i < element.getPrefix().size(); i++) { 1107 composeString(t, "HumanName", "prefix", element.getPrefix().get(i), i); 1108 } 1109 for (int i = 0; i < element.getSuffix().size(); i++) { 1110 composeString(t, "HumanName", "suffix", element.getSuffix().get(i), i); 1111 } 1112 if (element.hasPeriod()) { 1113 composePeriod(t, "HumanName", "period", element.getPeriod(), -1); 1114 } 1115 } 1116 1117 protected void composeIdentifier(Complex parent, String parentType, String name, Identifier element, int index) { 1118 if (element == null) 1119 return; 1120 Complex t; 1121 if (Utilities.noString(parentType)) 1122 t = parent; 1123 else { 1124 t = parent.predicate("fhir:"+parentType+'.'+name); 1125 } 1126 composeDataType(t, "Identifier", name, element, index); 1127 if (element.hasUseElement()) { 1128 composeEnum(t, "Identifier", "use", element.getUseElement(), -1); 1129 } 1130 if (element.hasType()) { 1131 composeCodeableConcept(t, "Identifier", "type", element.getType(), -1); 1132 } 1133 if (element.hasSystemElement()) { 1134 composeUri(t, "Identifier", "system", element.getSystemElement(), -1); 1135 } 1136 if (element.hasValueElement()) { 1137 composeString(t, "Identifier", "value", element.getValueElement(), -1); 1138 } 1139 if (element.hasPeriod()) { 1140 composePeriod(t, "Identifier", "period", element.getPeriod(), -1); 1141 } 1142 if (element.hasAssigner()) { 1143 composeReference(t, "Identifier", "assigner", element.getAssigner(), -1); 1144 } 1145 } 1146 1147 protected void composeMarketingStatus(Complex parent, String parentType, String name, MarketingStatus element, int index) { 1148 if (element == null) 1149 return; 1150 Complex t; 1151 if (Utilities.noString(parentType)) 1152 t = parent; 1153 else { 1154 t = parent.predicate("fhir:"+parentType+'.'+name); 1155 } 1156 composeBackboneType(t, "MarketingStatus", name, element, index); 1157 if (element.hasCountry()) { 1158 composeCodeableConcept(t, "MarketingStatus", "country", element.getCountry(), -1); 1159 } 1160 if (element.hasJurisdiction()) { 1161 composeCodeableConcept(t, "MarketingStatus", "jurisdiction", element.getJurisdiction(), -1); 1162 } 1163 if (element.hasStatus()) { 1164 composeCodeableConcept(t, "MarketingStatus", "status", element.getStatus(), -1); 1165 } 1166 if (element.hasDateRange()) { 1167 composePeriod(t, "MarketingStatus", "dateRange", element.getDateRange(), -1); 1168 } 1169 if (element.hasRestoreDateElement()) { 1170 composeDateTime(t, "MarketingStatus", "restoreDate", element.getRestoreDateElement(), -1); 1171 } 1172 } 1173 1174 protected void composeMeta(Complex parent, String parentType, String name, Meta element, int index) { 1175 if (element == null) 1176 return; 1177 Complex t; 1178 if (Utilities.noString(parentType)) 1179 t = parent; 1180 else { 1181 t = parent.predicate("fhir:"+parentType+'.'+name); 1182 } 1183 composeElement(t, "Meta", name, element, index); 1184 if (element.hasVersionIdElement()) { 1185 composeId(t, "Meta", "versionId", element.getVersionIdElement(), -1); 1186 } 1187 if (element.hasLastUpdatedElement()) { 1188 composeInstant(t, "Meta", "lastUpdated", element.getLastUpdatedElement(), -1); 1189 } 1190 if (element.hasSourceElement()) { 1191 composeUri(t, "Meta", "source", element.getSourceElement(), -1); 1192 } 1193 for (int i = 0; i < element.getProfile().size(); i++) { 1194 composeCanonical(t, "Meta", "profile", element.getProfile().get(i), i); 1195 } 1196 for (int i = 0; i < element.getSecurity().size(); i++) { 1197 composeCoding(t, "Meta", "security", element.getSecurity().get(i), i); 1198 } 1199 for (int i = 0; i < element.getTag().size(); i++) { 1200 composeCoding(t, "Meta", "tag", element.getTag().get(i), i); 1201 } 1202 } 1203 1204 protected void composeMoney(Complex parent, String parentType, String name, Money element, int index) { 1205 if (element == null) 1206 return; 1207 Complex t; 1208 if (Utilities.noString(parentType)) 1209 t = parent; 1210 else { 1211 t = parent.predicate("fhir:"+parentType+'.'+name); 1212 } 1213 composeDataType(t, "Money", name, element, index); 1214 if (element.hasValueElement()) { 1215 composeDecimal(t, "Money", "value", element.getValueElement(), -1); 1216 } 1217 if (element.hasCurrencyElement()) { 1218 composeCode(t, "Money", "currency", element.getCurrencyElement(), -1); 1219 } 1220 } 1221 1222 protected void composeNarrative(Complex parent, String parentType, String name, Narrative element, int index) { 1223 if (element == null) 1224 return; 1225 Complex t; 1226 if (Utilities.noString(parentType)) 1227 t = parent; 1228 else { 1229 t = parent.predicate("fhir:"+parentType+'.'+name); 1230 } 1231 composeDataType(t, "Narrative", name, element, index); 1232 if (element.hasStatusElement()) { 1233 composeEnum(t, "Narrative", "status", element.getStatusElement(), -1); 1234 } 1235 if (element.hasDiv()) { 1236 composeXhtmlNode(t, "Narrative", "div", element.getDiv(), -1); 1237 } 1238 } 1239 1240 protected void composeOrderedDistribution(Complex parent, String parentType, String name, OrderedDistribution element, int index) { 1241 if (element == null) 1242 return; 1243 Complex t; 1244 if (Utilities.noString(parentType)) 1245 t = parent; 1246 else { 1247 t = parent.predicate("fhir:"+parentType+'.'+name); 1248 } 1249 composeBackboneType(t, "OrderedDistribution", name, element, index); 1250 if (element.hasDescriptionElement()) { 1251 composeString(t, "OrderedDistribution", "description", element.getDescriptionElement(), -1); 1252 } 1253 for (int i = 0; i < element.getNote().size(); i++) { 1254 composeAnnotation(t, "OrderedDistribution", "note", element.getNote().get(i), i); 1255 } 1256 if (element.hasNumberOfIntervalsElement()) { 1257 composeInteger(t, "OrderedDistribution", "numberOfIntervals", element.getNumberOfIntervalsElement(), -1); 1258 } 1259 if (element.hasBottomOfFirstInterval()) { 1260 composeQuantity(t, "OrderedDistribution", "bottomOfFirstInterval", element.getBottomOfFirstInterval(), -1); 1261 } 1262 for (int i = 0; i < element.getInterval().size(); i++) { 1263 composeOrderedDistributionIntervalComponent(t, "OrderedDistribution", "interval", element.getInterval().get(i), i); 1264 } 1265 if (element.hasTopOfInterval()) { 1266 composeQuantity(t, "OrderedDistribution", "topOfInterval", element.getTopOfInterval(), -1); 1267 } 1268 } 1269 1270 protected void composeOrderedDistributionIntervalComponent(Complex parent, String parentType, String name, OrderedDistribution.OrderedDistributionIntervalComponent element, int index) { 1271 if (element == null) 1272 return; 1273 Complex t; 1274 if (Utilities.noString(parentType)) 1275 t = parent; 1276 else { 1277 t = parent.predicate("fhir:"+parentType+'.'+name); 1278 } 1279 composeElement(t, "interval", name, element, index); 1280 if (element.hasRankOrderElement()) { 1281 composeInteger(t, "OrderedDistributionIntervalComponent", "rankOrder", element.getRankOrderElement(), -1); 1282 } 1283 for (int i = 0; i < element.getIntervalStatistic().size(); i++) { 1284 composeStatistic(t, "OrderedDistributionIntervalComponent", "intervalStatistic", element.getIntervalStatistic().get(i), i); 1285 } 1286 } 1287 1288 protected void composeParameterDefinition(Complex parent, String parentType, String name, ParameterDefinition element, int index) { 1289 if (element == null) 1290 return; 1291 Complex t; 1292 if (Utilities.noString(parentType)) 1293 t = parent; 1294 else { 1295 t = parent.predicate("fhir:"+parentType+'.'+name); 1296 } 1297 composeDataType(t, "ParameterDefinition", name, element, index); 1298 if (element.hasNameElement()) { 1299 composeCode(t, "ParameterDefinition", "name", element.getNameElement(), -1); 1300 } 1301 if (element.hasUseElement()) { 1302 composeEnum(t, "ParameterDefinition", "use", element.getUseElement(), -1); 1303 } 1304 if (element.hasMinElement()) { 1305 composeInteger(t, "ParameterDefinition", "min", element.getMinElement(), -1); 1306 } 1307 if (element.hasMaxElement()) { 1308 composeString(t, "ParameterDefinition", "max", element.getMaxElement(), -1); 1309 } 1310 if (element.hasDocumentationElement()) { 1311 composeString(t, "ParameterDefinition", "documentation", element.getDocumentationElement(), -1); 1312 } 1313 if (element.hasTypeElement()) { 1314 composeEnum(t, "ParameterDefinition", "type", element.getTypeElement(), -1); 1315 } 1316 if (element.hasProfileElement()) { 1317 composeCanonical(t, "ParameterDefinition", "profile", element.getProfileElement(), -1); 1318 } 1319 } 1320 1321 protected void composePeriod(Complex parent, String parentType, String name, Period element, int index) { 1322 if (element == null) 1323 return; 1324 Complex t; 1325 if (Utilities.noString(parentType)) 1326 t = parent; 1327 else { 1328 t = parent.predicate("fhir:"+parentType+'.'+name); 1329 } 1330 composeDataType(t, "Period", name, element, index); 1331 if (element.hasStartElement()) { 1332 composeDateTime(t, "Period", "start", element.getStartElement(), -1); 1333 } 1334 if (element.hasEndElement()) { 1335 composeDateTime(t, "Period", "end", element.getEndElement(), -1); 1336 } 1337 } 1338 1339 protected void composePopulation(Complex parent, String parentType, String name, Population element, int index) { 1340 if (element == null) 1341 return; 1342 Complex t; 1343 if (Utilities.noString(parentType)) 1344 t = parent; 1345 else { 1346 t = parent.predicate("fhir:"+parentType+'.'+name); 1347 } 1348 composeBackboneType(t, "Population", name, element, index); 1349 if (element.hasAge()) { 1350 composeType(t, "Population", "age", element.getAge(), -1); 1351 } 1352 if (element.hasGender()) { 1353 composeCodeableConcept(t, "Population", "gender", element.getGender(), -1); 1354 } 1355 if (element.hasRace()) { 1356 composeCodeableConcept(t, "Population", "race", element.getRace(), -1); 1357 } 1358 if (element.hasPhysiologicalCondition()) { 1359 composeCodeableConcept(t, "Population", "physiologicalCondition", element.getPhysiologicalCondition(), -1); 1360 } 1361 } 1362 1363 protected void composeProdCharacteristic(Complex parent, String parentType, String name, ProdCharacteristic element, int index) { 1364 if (element == null) 1365 return; 1366 Complex t; 1367 if (Utilities.noString(parentType)) 1368 t = parent; 1369 else { 1370 t = parent.predicate("fhir:"+parentType+'.'+name); 1371 } 1372 composeBackboneType(t, "ProdCharacteristic", name, element, index); 1373 if (element.hasHeight()) { 1374 composeQuantity(t, "ProdCharacteristic", "height", element.getHeight(), -1); 1375 } 1376 if (element.hasWidth()) { 1377 composeQuantity(t, "ProdCharacteristic", "width", element.getWidth(), -1); 1378 } 1379 if (element.hasDepth()) { 1380 composeQuantity(t, "ProdCharacteristic", "depth", element.getDepth(), -1); 1381 } 1382 if (element.hasWeight()) { 1383 composeQuantity(t, "ProdCharacteristic", "weight", element.getWeight(), -1); 1384 } 1385 if (element.hasNominalVolume()) { 1386 composeQuantity(t, "ProdCharacteristic", "nominalVolume", element.getNominalVolume(), -1); 1387 } 1388 if (element.hasExternalDiameter()) { 1389 composeQuantity(t, "ProdCharacteristic", "externalDiameter", element.getExternalDiameter(), -1); 1390 } 1391 if (element.hasShapeElement()) { 1392 composeString(t, "ProdCharacteristic", "shape", element.getShapeElement(), -1); 1393 } 1394 for (int i = 0; i < element.getColor().size(); i++) { 1395 composeString(t, "ProdCharacteristic", "color", element.getColor().get(i), i); 1396 } 1397 for (int i = 0; i < element.getImprint().size(); i++) { 1398 composeString(t, "ProdCharacteristic", "imprint", element.getImprint().get(i), i); 1399 } 1400 for (int i = 0; i < element.getImage().size(); i++) { 1401 composeAttachment(t, "ProdCharacteristic", "image", element.getImage().get(i), i); 1402 } 1403 if (element.hasScoring()) { 1404 composeCodeableConcept(t, "ProdCharacteristic", "scoring", element.getScoring(), -1); 1405 } 1406 } 1407 1408 protected void composeProductShelfLife(Complex parent, String parentType, String name, ProductShelfLife element, int index) { 1409 if (element == null) 1410 return; 1411 Complex t; 1412 if (Utilities.noString(parentType)) 1413 t = parent; 1414 else { 1415 t = parent.predicate("fhir:"+parentType+'.'+name); 1416 } 1417 composeBackboneType(t, "ProductShelfLife", name, element, index); 1418 if (element.hasIdentifier()) { 1419 composeIdentifier(t, "ProductShelfLife", "identifier", element.getIdentifier(), -1); 1420 } 1421 if (element.hasType()) { 1422 composeCodeableConcept(t, "ProductShelfLife", "type", element.getType(), -1); 1423 } 1424 if (element.hasPeriod()) { 1425 composeQuantity(t, "ProductShelfLife", "period", element.getPeriod(), -1); 1426 } 1427 for (int i = 0; i < element.getSpecialPrecautionsForStorage().size(); i++) { 1428 composeCodeableConcept(t, "ProductShelfLife", "specialPrecautionsForStorage", element.getSpecialPrecautionsForStorage().get(i), i); 1429 } 1430 } 1431 1432 protected void composeQuantity(Complex parent, String parentType, String name, Quantity element, int index) { 1433 if (element == null) 1434 return; 1435 Complex t; 1436 if (Utilities.noString(parentType)) 1437 t = parent; 1438 else { 1439 t = parent.predicate("fhir:"+parentType+'.'+name); 1440 } 1441 composeDataType(t, "Quantity", name, element, index); 1442 if (element.hasValueElement()) { 1443 composeDecimal(t, "Quantity", "value", element.getValueElement(), -1); 1444 } 1445 if (element.hasComparatorElement()) { 1446 composeEnum(t, "Quantity", "comparator", element.getComparatorElement(), -1); 1447 } 1448 if (element.hasUnitElement()) { 1449 composeString(t, "Quantity", "unit", element.getUnitElement(), -1); 1450 } 1451 if (element.hasSystemElement()) { 1452 composeUri(t, "Quantity", "system", element.getSystemElement(), -1); 1453 } 1454 if (element.hasCodeElement()) { 1455 composeCode(t, "Quantity", "code", element.getCodeElement(), -1); 1456 } 1457 } 1458 1459 protected void composeRange(Complex parent, String parentType, String name, Range element, int index) { 1460 if (element == null) 1461 return; 1462 Complex t; 1463 if (Utilities.noString(parentType)) 1464 t = parent; 1465 else { 1466 t = parent.predicate("fhir:"+parentType+'.'+name); 1467 } 1468 composeDataType(t, "Range", name, element, index); 1469 if (element.hasLow()) { 1470 composeQuantity(t, "Range", "low", element.getLow(), -1); 1471 } 1472 if (element.hasHigh()) { 1473 composeQuantity(t, "Range", "high", element.getHigh(), -1); 1474 } 1475 } 1476 1477 protected void composeRatio(Complex parent, String parentType, String name, Ratio element, int index) { 1478 if (element == null) 1479 return; 1480 Complex t; 1481 if (Utilities.noString(parentType)) 1482 t = parent; 1483 else { 1484 t = parent.predicate("fhir:"+parentType+'.'+name); 1485 } 1486 composeDataType(t, "Ratio", name, element, index); 1487 if (element.hasNumerator()) { 1488 composeQuantity(t, "Ratio", "numerator", element.getNumerator(), -1); 1489 } 1490 if (element.hasDenominator()) { 1491 composeQuantity(t, "Ratio", "denominator", element.getDenominator(), -1); 1492 } 1493 } 1494 1495 protected void composeReference(Complex parent, String parentType, String name, Reference element, int index) { 1496 if (element == null) 1497 return; 1498 Complex t; 1499 if (Utilities.noString(parentType)) 1500 t = parent; 1501 else { 1502 t = parent.predicate("fhir:"+parentType+'.'+name); 1503 } 1504 composeDataType(t, "Reference", name, element, index); 1505 if (element.hasReferenceElement()) { 1506 composeString(t, "Reference", "reference", element.getReferenceElement_(), -1); 1507 } 1508 if (element.hasTypeElement()) { 1509 composeUri(t, "Reference", "type", element.getTypeElement(), -1); 1510 } 1511 if (element.hasIdentifier()) { 1512 composeIdentifier(t, "Reference", "identifier", element.getIdentifier(), -1); 1513 } 1514 if (element.hasDisplayElement()) { 1515 composeString(t, "Reference", "display", element.getDisplayElement(), -1); 1516 } 1517 } 1518 1519 protected void composeRelatedArtifact(Complex parent, String parentType, String name, RelatedArtifact element, int index) { 1520 if (element == null) 1521 return; 1522 Complex t; 1523 if (Utilities.noString(parentType)) 1524 t = parent; 1525 else { 1526 t = parent.predicate("fhir:"+parentType+'.'+name); 1527 } 1528 composeDataType(t, "RelatedArtifact", name, element, index); 1529 if (element.hasTypeElement()) { 1530 composeEnum(t, "RelatedArtifact", "type", element.getTypeElement(), -1); 1531 } 1532 if (element.hasLabelElement()) { 1533 composeString(t, "RelatedArtifact", "label", element.getLabelElement(), -1); 1534 } 1535 if (element.hasDisplayElement()) { 1536 composeString(t, "RelatedArtifact", "display", element.getDisplayElement(), -1); 1537 } 1538 if (element.hasCitationElement()) { 1539 composeMarkdown(t, "RelatedArtifact", "citation", element.getCitationElement(), -1); 1540 } 1541 if (element.hasUrlElement()) { 1542 composeUrl(t, "RelatedArtifact", "url", element.getUrlElement(), -1); 1543 } 1544 if (element.hasDocument()) { 1545 composeAttachment(t, "RelatedArtifact", "document", element.getDocument(), -1); 1546 } 1547 if (element.hasResourceElement()) { 1548 composeCanonical(t, "RelatedArtifact", "resource", element.getResourceElement(), -1); 1549 } 1550 } 1551 1552 protected void composeSampledData(Complex parent, String parentType, String name, SampledData element, int index) { 1553 if (element == null) 1554 return; 1555 Complex t; 1556 if (Utilities.noString(parentType)) 1557 t = parent; 1558 else { 1559 t = parent.predicate("fhir:"+parentType+'.'+name); 1560 } 1561 composeDataType(t, "SampledData", name, element, index); 1562 if (element.hasOrigin()) { 1563 composeQuantity(t, "SampledData", "origin", element.getOrigin(), -1); 1564 } 1565 if (element.hasPeriodElement()) { 1566 composeDecimal(t, "SampledData", "period", element.getPeriodElement(), -1); 1567 } 1568 if (element.hasFactorElement()) { 1569 composeDecimal(t, "SampledData", "factor", element.getFactorElement(), -1); 1570 } 1571 if (element.hasLowerLimitElement()) { 1572 composeDecimal(t, "SampledData", "lowerLimit", element.getLowerLimitElement(), -1); 1573 } 1574 if (element.hasUpperLimitElement()) { 1575 composeDecimal(t, "SampledData", "upperLimit", element.getUpperLimitElement(), -1); 1576 } 1577 if (element.hasDimensionsElement()) { 1578 composePositiveInt(t, "SampledData", "dimensions", element.getDimensionsElement(), -1); 1579 } 1580 if (element.hasDataElement()) { 1581 composeString(t, "SampledData", "data", element.getDataElement(), -1); 1582 } 1583 } 1584 1585 protected void composeSignature(Complex parent, String parentType, String name, Signature element, int index) { 1586 if (element == null) 1587 return; 1588 Complex t; 1589 if (Utilities.noString(parentType)) 1590 t = parent; 1591 else { 1592 t = parent.predicate("fhir:"+parentType+'.'+name); 1593 } 1594 composeDataType(t, "Signature", name, element, index); 1595 for (int i = 0; i < element.getType().size(); i++) { 1596 composeCoding(t, "Signature", "type", element.getType().get(i), i); 1597 } 1598 if (element.hasWhenElement()) { 1599 composeInstant(t, "Signature", "when", element.getWhenElement(), -1); 1600 } 1601 if (element.hasWho()) { 1602 composeReference(t, "Signature", "who", element.getWho(), -1); 1603 } 1604 if (element.hasOnBehalfOf()) { 1605 composeReference(t, "Signature", "onBehalfOf", element.getOnBehalfOf(), -1); 1606 } 1607 if (element.hasTargetFormatElement()) { 1608 composeCode(t, "Signature", "targetFormat", element.getTargetFormatElement(), -1); 1609 } 1610 if (element.hasSigFormatElement()) { 1611 composeCode(t, "Signature", "sigFormat", element.getSigFormatElement(), -1); 1612 } 1613 if (element.hasDataElement()) { 1614 composeBase64Binary(t, "Signature", "data", element.getDataElement(), -1); 1615 } 1616 } 1617 1618 protected void composeStatistic(Complex parent, String parentType, String name, Statistic element, int index) { 1619 if (element == null) 1620 return; 1621 Complex t; 1622 if (Utilities.noString(parentType)) 1623 t = parent; 1624 else { 1625 t = parent.predicate("fhir:"+parentType+'.'+name); 1626 } 1627 composeBackboneType(t, "Statistic", name, element, index); 1628 if (element.hasDescriptionElement()) { 1629 composeString(t, "Statistic", "description", element.getDescriptionElement(), -1); 1630 } 1631 for (int i = 0; i < element.getNote().size(); i++) { 1632 composeAnnotation(t, "Statistic", "note", element.getNote().get(i), i); 1633 } 1634 if (element.hasStatisticType()) { 1635 composeCodeableConcept(t, "Statistic", "statisticType", element.getStatisticType(), -1); 1636 } 1637 if (element.hasQuantity()) { 1638 composeQuantity(t, "Statistic", "quantity", element.getQuantity(), -1); 1639 } 1640 if (element.hasSampleSize()) { 1641 composeStatisticSampleSizeComponent(t, "Statistic", "sampleSize", element.getSampleSize(), -1); 1642 } 1643 for (int i = 0; i < element.getAttributeEstimate().size(); i++) { 1644 composeStatisticAttributeEstimateComponent(t, "Statistic", "attributeEstimate", element.getAttributeEstimate().get(i), i); 1645 } 1646 } 1647 1648 protected void composeStatisticSampleSizeComponent(Complex parent, String parentType, String name, Statistic.StatisticSampleSizeComponent element, int index) { 1649 if (element == null) 1650 return; 1651 Complex t; 1652 if (Utilities.noString(parentType)) 1653 t = parent; 1654 else { 1655 t = parent.predicate("fhir:"+parentType+'.'+name); 1656 } 1657 composeElement(t, "sampleSize", name, element, index); 1658 if (element.hasDescriptionElement()) { 1659 composeString(t, "StatisticSampleSizeComponent", "description", element.getDescriptionElement(), -1); 1660 } 1661 for (int i = 0; i < element.getNote().size(); i++) { 1662 composeAnnotation(t, "StatisticSampleSizeComponent", "note", element.getNote().get(i), i); 1663 } 1664 if (element.hasNumberOfStudiesElement()) { 1665 composeInteger(t, "StatisticSampleSizeComponent", "numberOfStudies", element.getNumberOfStudiesElement(), -1); 1666 } 1667 if (element.hasNumberOfParticipantsElement()) { 1668 composeInteger(t, "StatisticSampleSizeComponent", "numberOfParticipants", element.getNumberOfParticipantsElement(), -1); 1669 } 1670 if (element.hasKnownDataCountElement()) { 1671 composeInteger(t, "StatisticSampleSizeComponent", "knownDataCount", element.getKnownDataCountElement(), -1); 1672 } 1673 if (element.hasNumeratorCountElement()) { 1674 composeInteger(t, "StatisticSampleSizeComponent", "numeratorCount", element.getNumeratorCountElement(), -1); 1675 } 1676 } 1677 1678 protected void composeStatisticAttributeEstimateComponent(Complex parent, String parentType, String name, Statistic.StatisticAttributeEstimateComponent element, int index) { 1679 if (element == null) 1680 return; 1681 Complex t; 1682 if (Utilities.noString(parentType)) 1683 t = parent; 1684 else { 1685 t = parent.predicate("fhir:"+parentType+'.'+name); 1686 } 1687 composeElement(t, "attributeEstimate", name, element, index); 1688 if (element.hasDescriptionElement()) { 1689 composeString(t, "StatisticAttributeEstimateComponent", "description", element.getDescriptionElement(), -1); 1690 } 1691 for (int i = 0; i < element.getNote().size(); i++) { 1692 composeAnnotation(t, "StatisticAttributeEstimateComponent", "note", element.getNote().get(i), i); 1693 } 1694 if (element.hasType()) { 1695 composeCodeableConcept(t, "StatisticAttributeEstimateComponent", "type", element.getType(), -1); 1696 } 1697 if (element.hasQuantity()) { 1698 composeQuantity(t, "StatisticAttributeEstimateComponent", "quantity", element.getQuantity(), -1); 1699 } 1700 if (element.hasLevelElement()) { 1701 composeDecimal(t, "StatisticAttributeEstimateComponent", "level", element.getLevelElement(), -1); 1702 } 1703 if (element.hasRange()) { 1704 composeRange(t, "StatisticAttributeEstimateComponent", "range", element.getRange(), -1); 1705 } 1706 for (int i = 0; i < element.getEstimateQualifier().size(); i++) { 1707 composeStatisticAttributeEstimateEstimateQualifierComponent(t, "StatisticAttributeEstimateComponent", "estimateQualifier", element.getEstimateQualifier().get(i), i); 1708 } 1709 } 1710 1711 protected void composeStatisticAttributeEstimateEstimateQualifierComponent(Complex parent, String parentType, String name, Statistic.StatisticAttributeEstimateEstimateQualifierComponent element, int index) { 1712 if (element == null) 1713 return; 1714 Complex t; 1715 if (Utilities.noString(parentType)) 1716 t = parent; 1717 else { 1718 t = parent.predicate("fhir:"+parentType+'.'+name); 1719 } 1720 composeElement(t, "estimateQualifier", name, element, index); 1721 if (element.hasDescriptionElement()) { 1722 composeString(t, "StatisticAttributeEstimateEstimateQualifierComponent", "description", element.getDescriptionElement(), -1); 1723 } 1724 for (int i = 0; i < element.getNote().size(); i++) { 1725 composeAnnotation(t, "StatisticAttributeEstimateEstimateQualifierComponent", "note", element.getNote().get(i), i); 1726 } 1727 if (element.hasType()) { 1728 composeCodeableConcept(t, "StatisticAttributeEstimateEstimateQualifierComponent", "type", element.getType(), -1); 1729 } 1730 if (element.hasQuantity()) { 1731 composeQuantity(t, "StatisticAttributeEstimateEstimateQualifierComponent", "quantity", element.getQuantity(), -1); 1732 } 1733 if (element.hasLevelElement()) { 1734 composeDecimal(t, "StatisticAttributeEstimateEstimateQualifierComponent", "level", element.getLevelElement(), -1); 1735 } 1736 if (element.hasRange()) { 1737 composeRange(t, "StatisticAttributeEstimateEstimateQualifierComponent", "range", element.getRange(), -1); 1738 } 1739 } 1740 1741 protected void composeSubstanceAmount(Complex parent, String parentType, String name, SubstanceAmount element, int index) { 1742 if (element == null) 1743 return; 1744 Complex t; 1745 if (Utilities.noString(parentType)) 1746 t = parent; 1747 else { 1748 t = parent.predicate("fhir:"+parentType+'.'+name); 1749 } 1750 composeBackboneType(t, "SubstanceAmount", name, element, index); 1751 if (element.hasAmount()) { 1752 composeType(t, "SubstanceAmount", "amount", element.getAmount(), -1); 1753 } 1754 if (element.hasAmountType()) { 1755 composeCodeableConcept(t, "SubstanceAmount", "amountType", element.getAmountType(), -1); 1756 } 1757 if (element.hasAmountTextElement()) { 1758 composeString(t, "SubstanceAmount", "amountText", element.getAmountTextElement(), -1); 1759 } 1760 if (element.hasReferenceRange()) { 1761 composeSubstanceAmountReferenceRangeComponent(t, "SubstanceAmount", "referenceRange", element.getReferenceRange(), -1); 1762 } 1763 } 1764 1765 protected void composeSubstanceAmountReferenceRangeComponent(Complex parent, String parentType, String name, SubstanceAmount.SubstanceAmountReferenceRangeComponent element, int index) { 1766 if (element == null) 1767 return; 1768 Complex t; 1769 if (Utilities.noString(parentType)) 1770 t = parent; 1771 else { 1772 t = parent.predicate("fhir:"+parentType+'.'+name); 1773 } 1774 composeElement(t, "referenceRange", name, element, index); 1775 if (element.hasLowLimit()) { 1776 composeQuantity(t, "SubstanceAmountReferenceRangeComponent", "lowLimit", element.getLowLimit(), -1); 1777 } 1778 if (element.hasHighLimit()) { 1779 composeQuantity(t, "SubstanceAmountReferenceRangeComponent", "highLimit", element.getHighLimit(), -1); 1780 } 1781 } 1782 1783 protected void composeTiming(Complex parent, String parentType, String name, Timing element, int index) { 1784 if (element == null) 1785 return; 1786 Complex t; 1787 if (Utilities.noString(parentType)) 1788 t = parent; 1789 else { 1790 t = parent.predicate("fhir:"+parentType+'.'+name); 1791 } 1792 composeBackboneType(t, "Timing", name, element, index); 1793 for (int i = 0; i < element.getEvent().size(); i++) { 1794 composeDateTime(t, "Timing", "event", element.getEvent().get(i), i); 1795 } 1796 if (element.hasRepeat()) { 1797 composeTimingRepeatComponent(t, "Timing", "repeat", element.getRepeat(), -1); 1798 } 1799 if (element.hasCode()) { 1800 composeCodeableConcept(t, "Timing", "code", element.getCode(), -1); 1801 } 1802 } 1803 1804 protected void composeTimingRepeatComponent(Complex parent, String parentType, String name, Timing.TimingRepeatComponent element, int index) { 1805 if (element == null) 1806 return; 1807 Complex t; 1808 if (Utilities.noString(parentType)) 1809 t = parent; 1810 else { 1811 t = parent.predicate("fhir:"+parentType+'.'+name); 1812 } 1813 composeElement(t, "repeat", name, element, index); 1814 if (element.hasBounds()) { 1815 composeType(t, "TimingRepeatComponent", "bounds", element.getBounds(), -1); 1816 } 1817 if (element.hasCountElement()) { 1818 composePositiveInt(t, "TimingRepeatComponent", "count", element.getCountElement(), -1); 1819 } 1820 if (element.hasCountMaxElement()) { 1821 composePositiveInt(t, "TimingRepeatComponent", "countMax", element.getCountMaxElement(), -1); 1822 } 1823 if (element.hasDurationElement()) { 1824 composeDecimal(t, "TimingRepeatComponent", "duration", element.getDurationElement(), -1); 1825 } 1826 if (element.hasDurationMaxElement()) { 1827 composeDecimal(t, "TimingRepeatComponent", "durationMax", element.getDurationMaxElement(), -1); 1828 } 1829 if (element.hasDurationUnitElement()) { 1830 composeEnum(t, "TimingRepeatComponent", "durationUnit", element.getDurationUnitElement(), -1); 1831 } 1832 if (element.hasFrequencyElement()) { 1833 composePositiveInt(t, "TimingRepeatComponent", "frequency", element.getFrequencyElement(), -1); 1834 } 1835 if (element.hasFrequencyMaxElement()) { 1836 composePositiveInt(t, "TimingRepeatComponent", "frequencyMax", element.getFrequencyMaxElement(), -1); 1837 } 1838 if (element.hasPeriodElement()) { 1839 composeDecimal(t, "TimingRepeatComponent", "period", element.getPeriodElement(), -1); 1840 } 1841 if (element.hasPeriodMaxElement()) { 1842 composeDecimal(t, "TimingRepeatComponent", "periodMax", element.getPeriodMaxElement(), -1); 1843 } 1844 if (element.hasPeriodUnitElement()) { 1845 composeEnum(t, "TimingRepeatComponent", "periodUnit", element.getPeriodUnitElement(), -1); 1846 } 1847 for (int i = 0; i < element.getDayOfWeek().size(); i++) { 1848 composeEnum(t, "TimingRepeatComponent", "dayOfWeek", element.getDayOfWeek().get(i), i); 1849 } 1850 for (int i = 0; i < element.getTimeOfDay().size(); i++) { 1851 composeTime(t, "TimingRepeatComponent", "timeOfDay", element.getTimeOfDay().get(i), i); 1852 } 1853 for (int i = 0; i < element.getWhen().size(); i++) { 1854 composeEnum(t, "TimingRepeatComponent", "when", element.getWhen().get(i), i); 1855 } 1856 if (element.hasOffsetElement()) { 1857 composeUnsignedInt(t, "TimingRepeatComponent", "offset", element.getOffsetElement(), -1); 1858 } 1859 } 1860 1861 protected void composeTriggerDefinition(Complex parent, String parentType, String name, TriggerDefinition element, int index) { 1862 if (element == null) 1863 return; 1864 Complex t; 1865 if (Utilities.noString(parentType)) 1866 t = parent; 1867 else { 1868 t = parent.predicate("fhir:"+parentType+'.'+name); 1869 } 1870 composeDataType(t, "TriggerDefinition", name, element, index); 1871 if (element.hasTypeElement()) { 1872 composeEnum(t, "TriggerDefinition", "type", element.getTypeElement(), -1); 1873 } 1874 if (element.hasNameElement()) { 1875 composeString(t, "TriggerDefinition", "name", element.getNameElement(), -1); 1876 } 1877 if (element.hasTiming()) { 1878 composeType(t, "TriggerDefinition", "timing", element.getTiming(), -1); 1879 } 1880 for (int i = 0; i < element.getData().size(); i++) { 1881 composeDataRequirement(t, "TriggerDefinition", "data", element.getData().get(i), i); 1882 } 1883 if (element.hasCondition()) { 1884 composeExpression(t, "TriggerDefinition", "condition", element.getCondition(), -1); 1885 } 1886 } 1887 1888 protected void composeUsageContext(Complex parent, String parentType, String name, UsageContext 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 composeDataType(t, "UsageContext", name, element, index); 1898 if (element.hasCode()) { 1899 composeCoding(t, "UsageContext", "code", element.getCode(), -1); 1900 } 1901 if (element.hasValue()) { 1902 composeType(t, "UsageContext", "value", element.getValue(), -1); 1903 } 1904 } 1905 1906 protected void composeCanonicalResource(Complex t, String parentType, String name, CanonicalResource element, int index) { 1907 composeDomainResource(t, parentType, name, element, index); 1908 if (element.hasUrlElement()) { 1909 composeUri(t, "CanonicalResource", "url", element.getUrlElement(), -1); 1910 } 1911 for (int i = 0; i < element.getIdentifier().size(); i++) { 1912 composeIdentifier(t, "CanonicalResource", "identifier", element.getIdentifier().get(i), i); 1913 } 1914 if (element.hasVersionElement()) { 1915 composeString(t, "CanonicalResource", "version", element.getVersionElement(), -1); 1916 } 1917 if (element.hasNameElement()) { 1918 composeString(t, "CanonicalResource", "name", element.getNameElement(), -1); 1919 } 1920 if (element.hasTitleElement()) { 1921 composeString(t, "CanonicalResource", "title", element.getTitleElement(), -1); 1922 } 1923 if (element.hasStatusElement()) { 1924 composeEnum(t, "CanonicalResource", "status", element.getStatusElement(), -1); 1925 } 1926 if (element.hasExperimentalElement()) { 1927 composeBoolean(t, "CanonicalResource", "experimental", element.getExperimentalElement(), -1); 1928 } 1929 if (element.hasDateElement()) { 1930 composeDateTime(t, "CanonicalResource", "date", element.getDateElement(), -1); 1931 } 1932 if (element.hasPublisherElement()) { 1933 composeString(t, "CanonicalResource", "publisher", element.getPublisherElement(), -1); 1934 } 1935 for (int i = 0; i < element.getContact().size(); i++) { 1936 composeContactDetail(t, "CanonicalResource", "contact", element.getContact().get(i), i); 1937 } 1938 if (element.hasDescriptionElement()) { 1939 composeMarkdown(t, "CanonicalResource", "description", element.getDescriptionElement(), -1); 1940 } 1941 for (int i = 0; i < element.getUseContext().size(); i++) { 1942 composeUsageContext(t, "CanonicalResource", "useContext", element.getUseContext().get(i), i); 1943 } 1944 for (int i = 0; i < element.getJurisdiction().size(); i++) { 1945 composeCodeableConcept(t, "CanonicalResource", "jurisdiction", element.getJurisdiction().get(i), i); 1946 } 1947 if (element.hasPurposeElement()) { 1948 composeMarkdown(t, "CanonicalResource", "purpose", element.getPurposeElement(), -1); 1949 } 1950 if (element.hasCopyrightElement()) { 1951 composeMarkdown(t, "CanonicalResource", "copyright", element.getCopyrightElement(), -1); 1952 } 1953 } 1954 1955 protected void composeDomainResource(Complex t, String parentType, String name, DomainResource element, int index) { 1956 composeResource(t, parentType, name, element, index); 1957 if (element.hasText()) { 1958 composeNarrative(t, "DomainResource", "text", element.getText(), -1); 1959 } 1960 for (int i = 0; i < element.getContained().size(); i++) { 1961 composeResource(t, "DomainResource", "contained", element.getContained().get(i), i); 1962 } 1963 for (int i = 0; i < element.getExtension().size(); i++) { 1964 composeExtension(t, "DomainResource", "extension", element.getExtension().get(i), i); 1965 } 1966 for (int i = 0; i < element.getModifierExtension().size(); i++) { 1967 composeExtension(t, "DomainResource", "modifierExtension", element.getModifierExtension().get(i), i); 1968 } 1969 } 1970 1971 protected void composeMetadataResource(Complex t, String parentType, String name, MetadataResource element, int index) { 1972 composeCanonicalResource(t, parentType, name, element, index); 1973 if (element.hasApprovalDateElement()) { 1974 composeDate(t, "MetadataResource", "approvalDate", element.getApprovalDateElement(), -1); 1975 } 1976 if (element.hasLastReviewDateElement()) { 1977 composeDate(t, "MetadataResource", "lastReviewDate", element.getLastReviewDateElement(), -1); 1978 } 1979 if (element.hasEffectivePeriod()) { 1980 composePeriod(t, "MetadataResource", "effectivePeriod", element.getEffectivePeriod(), -1); 1981 } 1982 } 1983 1984 protected void composeResource(Complex t, String parentType, String name, Resource element, int index) { 1985 composeBase(t, parentType, name, element, index); 1986 if (element.hasIdElement()) { 1987 composeId(t, "Resource", "id", element.getIdElement(), -1); 1988 } 1989 if (element.hasMeta()) { 1990 composeMeta(t, "Resource", "meta", element.getMeta(), -1); 1991 } 1992 if (element.hasImplicitRulesElement()) { 1993 composeUri(t, "Resource", "implicitRules", element.getImplicitRulesElement(), -1); 1994 } 1995 if (element.hasLanguageElement()) { 1996 composeCode(t, "Resource", "language", element.getLanguageElement(), -1); 1997 } 1998 } 1999 2000 protected void composeAccount(Complex parent, String parentType, String name, Account element, int index) { 2001 if (element == null) 2002 return; 2003 Complex t; 2004 if (Utilities.noString(parentType)) 2005 t = parent; 2006 else { 2007 t = parent.predicate("fhir:"+parentType+'.'+name); 2008 } 2009 composeDomainResource(t, "Account", name, element, index); 2010 for (int i = 0; i < element.getIdentifier().size(); i++) { 2011 composeIdentifier(t, "Account", "identifier", element.getIdentifier().get(i), i); 2012 } 2013 if (element.hasStatusElement()) { 2014 composeEnum(t, "Account", "status", element.getStatusElement(), -1); 2015 } 2016 if (element.hasType()) { 2017 composeCodeableConcept(t, "Account", "type", element.getType(), -1); 2018 } 2019 if (element.hasNameElement()) { 2020 composeString(t, "Account", "name", element.getNameElement(), -1); 2021 } 2022 for (int i = 0; i < element.getSubject().size(); i++) { 2023 composeReference(t, "Account", "subject", element.getSubject().get(i), i); 2024 } 2025 if (element.hasServicePeriod()) { 2026 composePeriod(t, "Account", "servicePeriod", element.getServicePeriod(), -1); 2027 } 2028 for (int i = 0; i < element.getCoverage().size(); i++) { 2029 composeAccountCoverageComponent(t, "Account", "coverage", element.getCoverage().get(i), i); 2030 } 2031 if (element.hasOwner()) { 2032 composeReference(t, "Account", "owner", element.getOwner(), -1); 2033 } 2034 if (element.hasDescriptionElement()) { 2035 composeString(t, "Account", "description", element.getDescriptionElement(), -1); 2036 } 2037 for (int i = 0; i < element.getGuarantor().size(); i++) { 2038 composeAccountGuarantorComponent(t, "Account", "guarantor", element.getGuarantor().get(i), i); 2039 } 2040 if (element.hasPartOf()) { 2041 composeReference(t, "Account", "partOf", element.getPartOf(), -1); 2042 } 2043 } 2044 2045 protected void composeAccountCoverageComponent(Complex parent, String parentType, String name, Account.CoverageComponent element, int index) { 2046 if (element == null) 2047 return; 2048 Complex t; 2049 if (Utilities.noString(parentType)) 2050 t = parent; 2051 else { 2052 t = parent.predicate("fhir:"+parentType+'.'+name); 2053 } 2054 composeBackboneElement(t, "coverage", name, element, index); 2055 if (element.hasCoverage()) { 2056 composeReference(t, "CoverageComponent", "coverage", element.getCoverage(), -1); 2057 } 2058 if (element.hasPriorityElement()) { 2059 composePositiveInt(t, "CoverageComponent", "priority", element.getPriorityElement(), -1); 2060 } 2061 } 2062 2063 protected void composeAccountGuarantorComponent(Complex parent, String parentType, String name, Account.GuarantorComponent element, int index) { 2064 if (element == null) 2065 return; 2066 Complex t; 2067 if (Utilities.noString(parentType)) 2068 t = parent; 2069 else { 2070 t = parent.predicate("fhir:"+parentType+'.'+name); 2071 } 2072 composeBackboneElement(t, "guarantor", name, element, index); 2073 if (element.hasParty()) { 2074 composeReference(t, "GuarantorComponent", "party", element.getParty(), -1); 2075 } 2076 if (element.hasOnHoldElement()) { 2077 composeBoolean(t, "GuarantorComponent", "onHold", element.getOnHoldElement(), -1); 2078 } 2079 if (element.hasPeriod()) { 2080 composePeriod(t, "GuarantorComponent", "period", element.getPeriod(), -1); 2081 } 2082 } 2083 2084 protected void composeActivityDefinition(Complex parent, String parentType, String name, ActivityDefinition element, int index) { 2085 if (element == null) 2086 return; 2087 Complex t; 2088 if (Utilities.noString(parentType)) 2089 t = parent; 2090 else { 2091 t = parent.predicate("fhir:"+parentType+'.'+name); 2092 } 2093 composeMetadataResource(t, "ActivityDefinition", name, element, index); 2094 if (element.hasUrlElement()) { 2095 composeUri(t, "ActivityDefinition", "url", element.getUrlElement(), -1); 2096 } 2097 for (int i = 0; i < element.getIdentifier().size(); i++) { 2098 composeIdentifier(t, "ActivityDefinition", "identifier", element.getIdentifier().get(i), i); 2099 } 2100 if (element.hasVersionElement()) { 2101 composeString(t, "ActivityDefinition", "version", element.getVersionElement(), -1); 2102 } 2103 if (element.hasNameElement()) { 2104 composeString(t, "ActivityDefinition", "name", element.getNameElement(), -1); 2105 } 2106 if (element.hasTitleElement()) { 2107 composeString(t, "ActivityDefinition", "title", element.getTitleElement(), -1); 2108 } 2109 if (element.hasSubtitleElement()) { 2110 composeString(t, "ActivityDefinition", "subtitle", element.getSubtitleElement(), -1); 2111 } 2112 if (element.hasStatusElement()) { 2113 composeEnum(t, "ActivityDefinition", "status", element.getStatusElement(), -1); 2114 } 2115 if (element.hasExperimentalElement()) { 2116 composeBoolean(t, "ActivityDefinition", "experimental", element.getExperimentalElement(), -1); 2117 } 2118 if (element.hasSubject()) { 2119 composeType(t, "ActivityDefinition", "subject", element.getSubject(), -1); 2120 } 2121 if (element.hasDateElement()) { 2122 composeDateTime(t, "ActivityDefinition", "date", element.getDateElement(), -1); 2123 } 2124 if (element.hasPublisherElement()) { 2125 composeString(t, "ActivityDefinition", "publisher", element.getPublisherElement(), -1); 2126 } 2127 for (int i = 0; i < element.getContact().size(); i++) { 2128 composeContactDetail(t, "ActivityDefinition", "contact", element.getContact().get(i), i); 2129 } 2130 if (element.hasDescriptionElement()) { 2131 composeMarkdown(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1); 2132 } 2133 for (int i = 0; i < element.getUseContext().size(); i++) { 2134 composeUsageContext(t, "ActivityDefinition", "useContext", element.getUseContext().get(i), i); 2135 } 2136 for (int i = 0; i < element.getJurisdiction().size(); i++) { 2137 composeCodeableConcept(t, "ActivityDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 2138 } 2139 if (element.hasPurposeElement()) { 2140 composeMarkdown(t, "ActivityDefinition", "purpose", element.getPurposeElement(), -1); 2141 } 2142 if (element.hasUsageElement()) { 2143 composeString(t, "ActivityDefinition", "usage", element.getUsageElement(), -1); 2144 } 2145 if (element.hasCopyrightElement()) { 2146 composeMarkdown(t, "ActivityDefinition", "copyright", element.getCopyrightElement(), -1); 2147 } 2148 if (element.hasApprovalDateElement()) { 2149 composeDate(t, "ActivityDefinition", "approvalDate", element.getApprovalDateElement(), -1); 2150 } 2151 if (element.hasLastReviewDateElement()) { 2152 composeDate(t, "ActivityDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 2153 } 2154 if (element.hasEffectivePeriod()) { 2155 composePeriod(t, "ActivityDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 2156 } 2157 for (int i = 0; i < element.getTopic().size(); i++) { 2158 composeCodeableConcept(t, "ActivityDefinition", "topic", element.getTopic().get(i), i); 2159 } 2160 for (int i = 0; i < element.getAuthor().size(); i++) { 2161 composeContactDetail(t, "ActivityDefinition", "author", element.getAuthor().get(i), i); 2162 } 2163 for (int i = 0; i < element.getEditor().size(); i++) { 2164 composeContactDetail(t, "ActivityDefinition", "editor", element.getEditor().get(i), i); 2165 } 2166 for (int i = 0; i < element.getReviewer().size(); i++) { 2167 composeContactDetail(t, "ActivityDefinition", "reviewer", element.getReviewer().get(i), i); 2168 } 2169 for (int i = 0; i < element.getEndorser().size(); i++) { 2170 composeContactDetail(t, "ActivityDefinition", "endorser", element.getEndorser().get(i), i); 2171 } 2172 for (int i = 0; i < element.getRelatedArtifact().size(); i++) { 2173 composeRelatedArtifact(t, "ActivityDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 2174 } 2175 for (int i = 0; i < element.getLibrary().size(); i++) { 2176 composeCanonical(t, "ActivityDefinition", "library", element.getLibrary().get(i), i); 2177 } 2178 if (element.hasKindElement()) { 2179 composeEnum(t, "ActivityDefinition", "kind", element.getKindElement(), -1); 2180 } 2181 if (element.hasProfileElement()) { 2182 composeCanonical(t, "ActivityDefinition", "profile", element.getProfileElement(), -1); 2183 } 2184 if (element.hasCode()) { 2185 composeCodeableConcept(t, "ActivityDefinition", "code", element.getCode(), -1); 2186 } 2187 if (element.hasIntentElement()) { 2188 composeEnum(t, "ActivityDefinition", "intent", element.getIntentElement(), -1); 2189 } 2190 if (element.hasPriorityElement()) { 2191 composeEnum(t, "ActivityDefinition", "priority", element.getPriorityElement(), -1); 2192 } 2193 if (element.hasDoNotPerformElement()) { 2194 composeBoolean(t, "ActivityDefinition", "doNotPerform", element.getDoNotPerformElement(), -1); 2195 } 2196 if (element.hasTiming()) { 2197 composeType(t, "ActivityDefinition", "timing", element.getTiming(), -1); 2198 } 2199 if (element.hasLocation()) { 2200 composeReference(t, "ActivityDefinition", "location", element.getLocation(), -1); 2201 } 2202 for (int i = 0; i < element.getParticipant().size(); i++) { 2203 composeActivityDefinitionParticipantComponent(t, "ActivityDefinition", "participant", element.getParticipant().get(i), i); 2204 } 2205 if (element.hasProduct()) { 2206 composeType(t, "ActivityDefinition", "product", element.getProduct(), -1); 2207 } 2208 if (element.hasQuantity()) { 2209 composeQuantity(t, "ActivityDefinition", "quantity", element.getQuantity(), -1); 2210 } 2211 for (int i = 0; i < element.getDosage().size(); i++) { 2212 composeDosage(t, "ActivityDefinition", "dosage", element.getDosage().get(i), i); 2213 } 2214 for (int i = 0; i < element.getBodySite().size(); i++) { 2215 composeCodeableConcept(t, "ActivityDefinition", "bodySite", element.getBodySite().get(i), i); 2216 } 2217 for (int i = 0; i < element.getSpecimenRequirement().size(); i++) { 2218 composeReference(t, "ActivityDefinition", "specimenRequirement", element.getSpecimenRequirement().get(i), i); 2219 } 2220 for (int i = 0; i < element.getObservationRequirement().size(); i++) { 2221 composeReference(t, "ActivityDefinition", "observationRequirement", element.getObservationRequirement().get(i), i); 2222 } 2223 for (int i = 0; i < element.getObservationResultRequirement().size(); i++) { 2224 composeReference(t, "ActivityDefinition", "observationResultRequirement", element.getObservationResultRequirement().get(i), i); 2225 } 2226 if (element.hasTransformElement()) { 2227 composeCanonical(t, "ActivityDefinition", "transform", element.getTransformElement(), -1); 2228 } 2229 for (int i = 0; i < element.getDynamicValue().size(); i++) { 2230 composeActivityDefinitionDynamicValueComponent(t, "ActivityDefinition", "dynamicValue", element.getDynamicValue().get(i), i); 2231 } 2232 } 2233 2234 protected void composeActivityDefinitionParticipantComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionParticipantComponent 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 composeBackboneElement(t, "participant", name, element, index); 2244 if (element.hasTypeElement()) { 2245 composeEnum(t, "ActivityDefinitionParticipantComponent", "type", element.getTypeElement(), -1); 2246 } 2247 if (element.hasRole()) { 2248 composeCodeableConcept(t, "ActivityDefinitionParticipantComponent", "role", element.getRole(), -1); 2249 } 2250 } 2251 2252 protected void composeActivityDefinitionDynamicValueComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionDynamicValueComponent element, int index) { 2253 if (element == null) 2254 return; 2255 Complex t; 2256 if (Utilities.noString(parentType)) 2257 t = parent; 2258 else { 2259 t = parent.predicate("fhir:"+parentType+'.'+name); 2260 } 2261 composeBackboneElement(t, "dynamicValue", name, element, index); 2262 if (element.hasPathElement()) { 2263 composeString(t, "ActivityDefinitionDynamicValueComponent", "path", element.getPathElement(), -1); 2264 } 2265 if (element.hasExpression()) { 2266 composeExpression(t, "ActivityDefinitionDynamicValueComponent", "expression", element.getExpression(), -1); 2267 } 2268 } 2269 2270 protected void composeAdministrableProductDefinition(Complex parent, String parentType, String name, AdministrableProductDefinition element, int index) { 2271 if (element == null) 2272 return; 2273 Complex t; 2274 if (Utilities.noString(parentType)) 2275 t = parent; 2276 else { 2277 t = parent.predicate("fhir:"+parentType+'.'+name); 2278 } 2279 composeDomainResource(t, "AdministrableProductDefinition", name, element, index); 2280 for (int i = 0; i < element.getIdentifier().size(); i++) { 2281 composeIdentifier(t, "AdministrableProductDefinition", "identifier", element.getIdentifier().get(i), i); 2282 } 2283 for (int i = 0; i < element.getSubject().size(); i++) { 2284 composeReference(t, "AdministrableProductDefinition", "subject", element.getSubject().get(i), i); 2285 } 2286 if (element.hasAdministrableDoseForm()) { 2287 composeCodeableConcept(t, "AdministrableProductDefinition", "administrableDoseForm", element.getAdministrableDoseForm(), -1); 2288 } 2289 if (element.hasUnitOfPresentation()) { 2290 composeCodeableConcept(t, "AdministrableProductDefinition", "unitOfPresentation", element.getUnitOfPresentation(), -1); 2291 } 2292 for (int i = 0; i < element.getProducedFrom().size(); i++) { 2293 composeReference(t, "AdministrableProductDefinition", "producedFrom", element.getProducedFrom().get(i), i); 2294 } 2295 for (int i = 0; i < element.getIngredient().size(); i++) { 2296 composeReference(t, "AdministrableProductDefinition", "ingredient", element.getIngredient().get(i), i); 2297 } 2298 for (int i = 0; i < element.getDevice().size(); i++) { 2299 composeReference(t, "AdministrableProductDefinition", "device", element.getDevice().get(i), i); 2300 } 2301 for (int i = 0; i < element.getCharacteristic().size(); i++) { 2302 composeAdministrableProductDefinitionCharacteristicComponent(t, "AdministrableProductDefinition", "characteristic", element.getCharacteristic().get(i), i); 2303 } 2304 for (int i = 0; i < element.getRouteOfAdministration().size(); i++) { 2305 composeAdministrableProductDefinitionRouteOfAdministrationComponent(t, "AdministrableProductDefinition", "routeOfAdministration", element.getRouteOfAdministration().get(i), i); 2306 } 2307 } 2308 2309 protected void composeAdministrableProductDefinitionCharacteristicComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionCharacteristicComponent element, int index) { 2310 if (element == null) 2311 return; 2312 Complex t; 2313 if (Utilities.noString(parentType)) 2314 t = parent; 2315 else { 2316 t = parent.predicate("fhir:"+parentType+'.'+name); 2317 } 2318 composeBackboneElement(t, "characteristic", name, element, index); 2319 if (element.hasCode()) { 2320 composeCodeableConcept(t, "AdministrableProductDefinitionCharacteristicComponent", "code", element.getCode(), -1); 2321 } 2322 if (element.hasValue()) { 2323 composeType(t, "AdministrableProductDefinitionCharacteristicComponent", "value", element.getValue(), -1); 2324 } 2325 if (element.hasStatus()) { 2326 composeCodeableConcept(t, "AdministrableProductDefinitionCharacteristicComponent", "status", element.getStatus(), -1); 2327 } 2328 } 2329 2330 protected void composeAdministrableProductDefinitionRouteOfAdministrationComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationComponent element, int index) { 2331 if (element == null) 2332 return; 2333 Complex t; 2334 if (Utilities.noString(parentType)) 2335 t = parent; 2336 else { 2337 t = parent.predicate("fhir:"+parentType+'.'+name); 2338 } 2339 composeBackboneElement(t, "routeOfAdministration", name, element, index); 2340 if (element.hasCode()) { 2341 composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "code", element.getCode(), -1); 2342 } 2343 if (element.hasFirstDose()) { 2344 composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "firstDose", element.getFirstDose(), -1); 2345 } 2346 if (element.hasMaxSingleDose()) { 2347 composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxSingleDose", element.getMaxSingleDose(), -1); 2348 } 2349 if (element.hasMaxDosePerDay()) { 2350 composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxDosePerDay", element.getMaxDosePerDay(), -1); 2351 } 2352 if (element.hasMaxDosePerTreatmentPeriod()) { 2353 composeRatio(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxDosePerTreatmentPeriod", element.getMaxDosePerTreatmentPeriod(), -1); 2354 } 2355 if (element.hasMaxTreatmentPeriod()) { 2356 composeDuration(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxTreatmentPeriod", element.getMaxTreatmentPeriod(), -1); 2357 } 2358 for (int i = 0; i < element.getTargetSpecies().size(); i++) { 2359 composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "targetSpecies", element.getTargetSpecies().get(i), i); 2360 } 2361 } 2362 2363 protected void composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent element, int index) { 2364 if (element == null) 2365 return; 2366 Complex t; 2367 if (Utilities.noString(parentType)) 2368 t = parent; 2369 else { 2370 t = parent.predicate("fhir:"+parentType+'.'+name); 2371 } 2372 composeBackboneElement(t, "targetSpecies", name, element, index); 2373 if (element.hasCode()) { 2374 composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent", "code", element.getCode(), -1); 2375 } 2376 for (int i = 0; i < element.getWithdrawalPeriod().size(); i++) { 2377 composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent", "withdrawalPeriod", element.getWithdrawalPeriod().get(i), i); 2378 } 2379 } 2380 2381 protected void composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent element, int index) { 2382 if (element == null) 2383 return; 2384 Complex t; 2385 if (Utilities.noString(parentType)) 2386 t = parent; 2387 else { 2388 t = parent.predicate("fhir:"+parentType+'.'+name); 2389 } 2390 composeBackboneElement(t, "withdrawalPeriod", name, element, index); 2391 if (element.hasTissue()) { 2392 composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "tissue", element.getTissue(), -1); 2393 } 2394 if (element.hasValue()) { 2395 composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "value", element.getValue(), -1); 2396 } 2397 if (element.hasSupportingInformationElement()) { 2398 composeString(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "supportingInformation", element.getSupportingInformationElement(), -1); 2399 } 2400 } 2401 2402 protected void composeAdverseEvent(Complex parent, String parentType, String name, AdverseEvent element, int index) { 2403 if (element == null) 2404 return; 2405 Complex t; 2406 if (Utilities.noString(parentType)) 2407 t = parent; 2408 else { 2409 t = parent.predicate("fhir:"+parentType+'.'+name); 2410 } 2411 composeDomainResource(t, "AdverseEvent", name, element, index); 2412 for (int i = 0; i < element.getIdentifier().size(); i++) { 2413 composeIdentifier(t, "AdverseEvent", "identifier", element.getIdentifier().get(i), i); 2414 } 2415 if (element.hasStatusElement()) { 2416 composeEnum(t, "AdverseEvent", "status", element.getStatusElement(), -1); 2417 } 2418 if (element.hasActualityElement()) { 2419 composeEnum(t, "AdverseEvent", "actuality", element.getActualityElement(), -1); 2420 } 2421 for (int i = 0; i < element.getCategory().size(); i++) { 2422 composeCodeableConcept(t, "AdverseEvent", "category", element.getCategory().get(i), i); 2423 } 2424 if (element.hasCode()) { 2425 composeCodeableConcept(t, "AdverseEvent", "code", element.getCode(), -1); 2426 } 2427 if (element.hasSubject()) { 2428 composeReference(t, "AdverseEvent", "subject", element.getSubject(), -1); 2429 } 2430 if (element.hasEncounter()) { 2431 composeReference(t, "AdverseEvent", "encounter", element.getEncounter(), -1); 2432 } 2433 if (element.hasOccurrence()) { 2434 composeType(t, "AdverseEvent", "occurrence", element.getOccurrence(), -1); 2435 } 2436 if (element.hasDetectedElement()) { 2437 composeDateTime(t, "AdverseEvent", "detected", element.getDetectedElement(), -1); 2438 } 2439 if (element.hasRecordedDateElement()) { 2440 composeDateTime(t, "AdverseEvent", "recordedDate", element.getRecordedDateElement(), -1); 2441 } 2442 for (int i = 0; i < element.getResultingCondition().size(); i++) { 2443 composeReference(t, "AdverseEvent", "resultingCondition", element.getResultingCondition().get(i), i); 2444 } 2445 if (element.hasLocation()) { 2446 composeReference(t, "AdverseEvent", "location", element.getLocation(), -1); 2447 } 2448 if (element.hasSeriousness()) { 2449 composeCodeableConcept(t, "AdverseEvent", "seriousness", element.getSeriousness(), -1); 2450 } 2451 if (element.hasOutcome()) { 2452 composeCodeableConcept(t, "AdverseEvent", "outcome", element.getOutcome(), -1); 2453 } 2454 if (element.hasRecorder()) { 2455 composeReference(t, "AdverseEvent", "recorder", element.getRecorder(), -1); 2456 } 2457 for (int i = 0; i < element.getParticipant().size(); i++) { 2458 composeAdverseEventParticipantComponent(t, "AdverseEvent", "participant", element.getParticipant().get(i), i); 2459 } 2460 for (int i = 0; i < element.getSuspectEntity().size(); i++) { 2461 composeAdverseEventSuspectEntityComponent(t, "AdverseEvent", "suspectEntity", element.getSuspectEntity().get(i), i); 2462 } 2463 for (int i = 0; i < element.getContributingFactor().size(); i++) { 2464 composeAdverseEventContributingFactorComponent(t, "AdverseEvent", "contributingFactor", element.getContributingFactor().get(i), i); 2465 } 2466 for (int i = 0; i < element.getPreventiveAction().size(); i++) { 2467 composeAdverseEventPreventiveActionComponent(t, "AdverseEvent", "preventiveAction", element.getPreventiveAction().get(i), i); 2468 } 2469 for (int i = 0; i < element.getMitigatingAction().size(); i++) { 2470 composeAdverseEventMitigatingActionComponent(t, "AdverseEvent", "mitigatingAction", element.getMitigatingAction().get(i), i); 2471 } 2472 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 2473 composeAdverseEventSupportingInfoComponent(t, "AdverseEvent", "supportingInfo", element.getSupportingInfo().get(i), i); 2474 } 2475 for (int i = 0; i < element.getStudy().size(); i++) { 2476 composeReference(t, "AdverseEvent", "study", element.getStudy().get(i), i); 2477 } 2478 } 2479 2480 protected void composeAdverseEventParticipantComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventParticipantComponent element, int index) { 2481 if (element == null) 2482 return; 2483 Complex t; 2484 if (Utilities.noString(parentType)) 2485 t = parent; 2486 else { 2487 t = parent.predicate("fhir:"+parentType+'.'+name); 2488 } 2489 composeBackboneElement(t, "participant", name, element, index); 2490 if (element.hasFunction()) { 2491 composeCodeableConcept(t, "AdverseEventParticipantComponent", "function", element.getFunction(), -1); 2492 } 2493 if (element.hasActor()) { 2494 composeReference(t, "AdverseEventParticipantComponent", "actor", element.getActor(), -1); 2495 } 2496 } 2497 2498 protected void composeAdverseEventSuspectEntityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityComponent element, int index) { 2499 if (element == null) 2500 return; 2501 Complex t; 2502 if (Utilities.noString(parentType)) 2503 t = parent; 2504 else { 2505 t = parent.predicate("fhir:"+parentType+'.'+name); 2506 } 2507 composeBackboneElement(t, "suspectEntity", name, element, index); 2508 if (element.hasInstance()) { 2509 composeType(t, "AdverseEventSuspectEntityComponent", "instance", element.getInstance(), -1); 2510 } 2511 if (element.hasCausality()) { 2512 composeAdverseEventSuspectEntityCausalityComponent(t, "AdverseEventSuspectEntityComponent", "causality", element.getCausality(), -1); 2513 } 2514 } 2515 2516 protected void composeAdverseEventSuspectEntityCausalityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityCausalityComponent element, int index) { 2517 if (element == null) 2518 return; 2519 Complex t; 2520 if (Utilities.noString(parentType)) 2521 t = parent; 2522 else { 2523 t = parent.predicate("fhir:"+parentType+'.'+name); 2524 } 2525 composeBackboneElement(t, "causality", name, element, index); 2526 if (element.hasAssessmentMethod()) { 2527 composeCodeableConcept(t, "AdverseEventSuspectEntityCausalityComponent", "assessmentMethod", element.getAssessmentMethod(), -1); 2528 } 2529 if (element.hasEntityRelatedness()) { 2530 composeCodeableConcept(t, "AdverseEventSuspectEntityCausalityComponent", "entityRelatedness", element.getEntityRelatedness(), -1); 2531 } 2532 if (element.hasAuthor()) { 2533 composeReference(t, "AdverseEventSuspectEntityCausalityComponent", "author", element.getAuthor(), -1); 2534 } 2535 } 2536 2537 protected void composeAdverseEventContributingFactorComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventContributingFactorComponent element, int index) { 2538 if (element == null) 2539 return; 2540 Complex t; 2541 if (Utilities.noString(parentType)) 2542 t = parent; 2543 else { 2544 t = parent.predicate("fhir:"+parentType+'.'+name); 2545 } 2546 composeBackboneElement(t, "contributingFactor", name, element, index); 2547 if (element.hasItem()) { 2548 composeType(t, "AdverseEventContributingFactorComponent", "item", element.getItem(), -1); 2549 } 2550 } 2551 2552 protected void composeAdverseEventPreventiveActionComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventPreventiveActionComponent element, int index) { 2553 if (element == null) 2554 return; 2555 Complex t; 2556 if (Utilities.noString(parentType)) 2557 t = parent; 2558 else { 2559 t = parent.predicate("fhir:"+parentType+'.'+name); 2560 } 2561 composeBackboneElement(t, "preventiveAction", name, element, index); 2562 if (element.hasItem()) { 2563 composeType(t, "AdverseEventPreventiveActionComponent", "item", element.getItem(), -1); 2564 } 2565 } 2566 2567 protected void composeAdverseEventMitigatingActionComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventMitigatingActionComponent element, int index) { 2568 if (element == null) 2569 return; 2570 Complex t; 2571 if (Utilities.noString(parentType)) 2572 t = parent; 2573 else { 2574 t = parent.predicate("fhir:"+parentType+'.'+name); 2575 } 2576 composeBackboneElement(t, "mitigatingAction", name, element, index); 2577 if (element.hasItem()) { 2578 composeType(t, "AdverseEventMitigatingActionComponent", "item", element.getItem(), -1); 2579 } 2580 } 2581 2582 protected void composeAdverseEventSupportingInfoComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSupportingInfoComponent 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, "supportingInfo", name, element, index); 2592 if (element.hasItem()) { 2593 composeType(t, "AdverseEventSupportingInfoComponent", "item", element.getItem(), -1); 2594 } 2595 } 2596 2597 protected void composeAllergyIntolerance(Complex parent, String parentType, String name, AllergyIntolerance element, int index) { 2598 if (element == null) 2599 return; 2600 Complex t; 2601 if (Utilities.noString(parentType)) 2602 t = parent; 2603 else { 2604 t = parent.predicate("fhir:"+parentType+'.'+name); 2605 } 2606 composeDomainResource(t, "AllergyIntolerance", name, element, index); 2607 for (int i = 0; i < element.getIdentifier().size(); i++) { 2608 composeIdentifier(t, "AllergyIntolerance", "identifier", element.getIdentifier().get(i), i); 2609 } 2610 if (element.hasClinicalStatus()) { 2611 composeCodeableConcept(t, "AllergyIntolerance", "clinicalStatus", element.getClinicalStatus(), -1); 2612 } 2613 if (element.hasVerificationStatus()) { 2614 composeCodeableConcept(t, "AllergyIntolerance", "verificationStatus", element.getVerificationStatus(), -1); 2615 } 2616 if (element.hasTypeElement()) { 2617 composeEnum(t, "AllergyIntolerance", "type", element.getTypeElement(), -1); 2618 } 2619 for (int i = 0; i < element.getCategory().size(); i++) { 2620 composeEnum(t, "AllergyIntolerance", "category", element.getCategory().get(i), i); 2621 } 2622 if (element.hasCriticalityElement()) { 2623 composeEnum(t, "AllergyIntolerance", "criticality", element.getCriticalityElement(), -1); 2624 } 2625 if (element.hasCode()) { 2626 composeCodeableConcept(t, "AllergyIntolerance", "code", element.getCode(), -1); 2627 } 2628 if (element.hasPatient()) { 2629 composeReference(t, "AllergyIntolerance", "patient", element.getPatient(), -1); 2630 } 2631 if (element.hasEncounter()) { 2632 composeReference(t, "AllergyIntolerance", "encounter", element.getEncounter(), -1); 2633 } 2634 if (element.hasOnset()) { 2635 composeType(t, "AllergyIntolerance", "onset", element.getOnset(), -1); 2636 } 2637 if (element.hasRecordedDateElement()) { 2638 composeDateTime(t, "AllergyIntolerance", "recordedDate", element.getRecordedDateElement(), -1); 2639 } 2640 if (element.hasRecorder()) { 2641 composeReference(t, "AllergyIntolerance", "recorder", element.getRecorder(), -1); 2642 } 2643 if (element.hasAsserter()) { 2644 composeReference(t, "AllergyIntolerance", "asserter", element.getAsserter(), -1); 2645 } 2646 if (element.hasLastOccurrenceElement()) { 2647 composeDateTime(t, "AllergyIntolerance", "lastOccurrence", element.getLastOccurrenceElement(), -1); 2648 } 2649 for (int i = 0; i < element.getNote().size(); i++) { 2650 composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i); 2651 } 2652 for (int i = 0; i < element.getReaction().size(); i++) { 2653 composeAllergyIntoleranceReactionComponent(t, "AllergyIntolerance", "reaction", element.getReaction().get(i), i); 2654 } 2655 } 2656 2657 protected void composeAllergyIntoleranceReactionComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceReactionComponent element, int index) { 2658 if (element == null) 2659 return; 2660 Complex t; 2661 if (Utilities.noString(parentType)) 2662 t = parent; 2663 else { 2664 t = parent.predicate("fhir:"+parentType+'.'+name); 2665 } 2666 composeBackboneElement(t, "reaction", name, element, index); 2667 if (element.hasSubstance()) { 2668 composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "substance", element.getSubstance(), -1); 2669 } 2670 for (int i = 0; i < element.getManifestation().size(); i++) { 2671 composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "manifestation", element.getManifestation().get(i), i); 2672 } 2673 if (element.hasDescriptionElement()) { 2674 composeString(t, "AllergyIntoleranceReactionComponent", "description", element.getDescriptionElement(), -1); 2675 } 2676 if (element.hasOnsetElement()) { 2677 composeDateTime(t, "AllergyIntoleranceReactionComponent", "onset", element.getOnsetElement(), -1); 2678 } 2679 if (element.hasSeverityElement()) { 2680 composeEnum(t, "AllergyIntoleranceReactionComponent", "severity", element.getSeverityElement(), -1); 2681 } 2682 if (element.hasExposureRoute()) { 2683 composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "exposureRoute", element.getExposureRoute(), -1); 2684 } 2685 for (int i = 0; i < element.getNote().size(); i++) { 2686 composeAnnotation(t, "AllergyIntoleranceReactionComponent", "note", element.getNote().get(i), i); 2687 } 2688 } 2689 2690 protected void composeAppointment(Complex parent, String parentType, String name, Appointment element, int index) { 2691 if (element == null) 2692 return; 2693 Complex t; 2694 if (Utilities.noString(parentType)) 2695 t = parent; 2696 else { 2697 t = parent.predicate("fhir:"+parentType+'.'+name); 2698 } 2699 composeDomainResource(t, "Appointment", name, element, index); 2700 for (int i = 0; i < element.getIdentifier().size(); i++) { 2701 composeIdentifier(t, "Appointment", "identifier", element.getIdentifier().get(i), i); 2702 } 2703 if (element.hasStatusElement()) { 2704 composeEnum(t, "Appointment", "status", element.getStatusElement(), -1); 2705 } 2706 if (element.hasCancelationReason()) { 2707 composeCodeableConcept(t, "Appointment", "cancelationReason", element.getCancelationReason(), -1); 2708 } 2709 for (int i = 0; i < element.getServiceCategory().size(); i++) { 2710 composeCodeableConcept(t, "Appointment", "serviceCategory", element.getServiceCategory().get(i), i); 2711 } 2712 for (int i = 0; i < element.getServiceType().size(); i++) { 2713 composeCodeableConcept(t, "Appointment", "serviceType", element.getServiceType().get(i), i); 2714 } 2715 for (int i = 0; i < element.getSpecialty().size(); i++) { 2716 composeCodeableConcept(t, "Appointment", "specialty", element.getSpecialty().get(i), i); 2717 } 2718 if (element.hasAppointmentType()) { 2719 composeCodeableConcept(t, "Appointment", "appointmentType", element.getAppointmentType(), -1); 2720 } 2721 for (int i = 0; i < element.getReason().size(); i++) { 2722 composeCodeableReference(t, "Appointment", "reason", element.getReason().get(i), i); 2723 } 2724 if (element.hasPriorityElement()) { 2725 composeUnsignedInt(t, "Appointment", "priority", element.getPriorityElement(), -1); 2726 } 2727 if (element.hasDescriptionElement()) { 2728 composeString(t, "Appointment", "description", element.getDescriptionElement(), -1); 2729 } 2730 for (int i = 0; i < element.getSupportingInformation().size(); i++) { 2731 composeReference(t, "Appointment", "supportingInformation", element.getSupportingInformation().get(i), i); 2732 } 2733 if (element.hasStartElement()) { 2734 composeInstant(t, "Appointment", "start", element.getStartElement(), -1); 2735 } 2736 if (element.hasEndElement()) { 2737 composeInstant(t, "Appointment", "end", element.getEndElement(), -1); 2738 } 2739 if (element.hasMinutesDurationElement()) { 2740 composePositiveInt(t, "Appointment", "minutesDuration", element.getMinutesDurationElement(), -1); 2741 } 2742 for (int i = 0; i < element.getSlot().size(); i++) { 2743 composeReference(t, "Appointment", "slot", element.getSlot().get(i), i); 2744 } 2745 if (element.hasCreatedElement()) { 2746 composeDateTime(t, "Appointment", "created", element.getCreatedElement(), -1); 2747 } 2748 if (element.hasCommentElement()) { 2749 composeString(t, "Appointment", "comment", element.getCommentElement(), -1); 2750 } 2751 if (element.hasPatientInstructionElement()) { 2752 composeString(t, "Appointment", "patientInstruction", element.getPatientInstructionElement(), -1); 2753 } 2754 for (int i = 0; i < element.getBasedOn().size(); i++) { 2755 composeReference(t, "Appointment", "basedOn", element.getBasedOn().get(i), i); 2756 } 2757 for (int i = 0; i < element.getParticipant().size(); i++) { 2758 composeAppointmentParticipantComponent(t, "Appointment", "participant", element.getParticipant().get(i), i); 2759 } 2760 for (int i = 0; i < element.getRequestedPeriod().size(); i++) { 2761 composePeriod(t, "Appointment", "requestedPeriod", element.getRequestedPeriod().get(i), i); 2762 } 2763 } 2764 2765 protected void composeAppointmentParticipantComponent(Complex parent, String parentType, String name, Appointment.AppointmentParticipantComponent element, int index) { 2766 if (element == null) 2767 return; 2768 Complex t; 2769 if (Utilities.noString(parentType)) 2770 t = parent; 2771 else { 2772 t = parent.predicate("fhir:"+parentType+'.'+name); 2773 } 2774 composeBackboneElement(t, "participant", name, element, index); 2775 for (int i = 0; i < element.getType().size(); i++) { 2776 composeCodeableConcept(t, "AppointmentParticipantComponent", "type", element.getType().get(i), i); 2777 } 2778 if (element.hasActor()) { 2779 composeReference(t, "AppointmentParticipantComponent", "actor", element.getActor(), -1); 2780 } 2781 if (element.hasRequiredElement()) { 2782 composeEnum(t, "AppointmentParticipantComponent", "required", element.getRequiredElement(), -1); 2783 } 2784 if (element.hasStatusElement()) { 2785 composeEnum(t, "AppointmentParticipantComponent", "status", element.getStatusElement(), -1); 2786 } 2787 if (element.hasPeriod()) { 2788 composePeriod(t, "AppointmentParticipantComponent", "period", element.getPeriod(), -1); 2789 } 2790 } 2791 2792 protected void composeAppointmentResponse(Complex parent, String parentType, String name, AppointmentResponse element, int index) { 2793 if (element == null) 2794 return; 2795 Complex t; 2796 if (Utilities.noString(parentType)) 2797 t = parent; 2798 else { 2799 t = parent.predicate("fhir:"+parentType+'.'+name); 2800 } 2801 composeDomainResource(t, "AppointmentResponse", name, element, index); 2802 for (int i = 0; i < element.getIdentifier().size(); i++) { 2803 composeIdentifier(t, "AppointmentResponse", "identifier", element.getIdentifier().get(i), i); 2804 } 2805 if (element.hasAppointment()) { 2806 composeReference(t, "AppointmentResponse", "appointment", element.getAppointment(), -1); 2807 } 2808 if (element.hasStartElement()) { 2809 composeInstant(t, "AppointmentResponse", "start", element.getStartElement(), -1); 2810 } 2811 if (element.hasEndElement()) { 2812 composeInstant(t, "AppointmentResponse", "end", element.getEndElement(), -1); 2813 } 2814 for (int i = 0; i < element.getParticipantType().size(); i++) { 2815 composeCodeableConcept(t, "AppointmentResponse", "participantType", element.getParticipantType().get(i), i); 2816 } 2817 if (element.hasActor()) { 2818 composeReference(t, "AppointmentResponse", "actor", element.getActor(), -1); 2819 } 2820 if (element.hasParticipantStatusElement()) { 2821 composeEnum(t, "AppointmentResponse", "participantStatus", element.getParticipantStatusElement(), -1); 2822 } 2823 if (element.hasCommentElement()) { 2824 composeString(t, "AppointmentResponse", "comment", element.getCommentElement(), -1); 2825 } 2826 } 2827 2828 protected void composeAuditEvent(Complex parent, String parentType, String name, AuditEvent element, int index) { 2829 if (element == null) 2830 return; 2831 Complex t; 2832 if (Utilities.noString(parentType)) 2833 t = parent; 2834 else { 2835 t = parent.predicate("fhir:"+parentType+'.'+name); 2836 } 2837 composeDomainResource(t, "AuditEvent", name, element, index); 2838 if (element.hasType()) { 2839 composeCoding(t, "AuditEvent", "type", element.getType(), -1); 2840 } 2841 for (int i = 0; i < element.getSubtype().size(); i++) { 2842 composeCoding(t, "AuditEvent", "subtype", element.getSubtype().get(i), i); 2843 } 2844 if (element.hasActionElement()) { 2845 composeEnum(t, "AuditEvent", "action", element.getActionElement(), -1); 2846 } 2847 if (element.hasSeverityElement()) { 2848 composeEnum(t, "AuditEvent", "severity", element.getSeverityElement(), -1); 2849 } 2850 if (element.hasPeriod()) { 2851 composePeriod(t, "AuditEvent", "period", element.getPeriod(), -1); 2852 } 2853 if (element.hasRecordedElement()) { 2854 composeInstant(t, "AuditEvent", "recorded", element.getRecordedElement(), -1); 2855 } 2856 if (element.hasOutcomeElement()) { 2857 composeEnum(t, "AuditEvent", "outcome", element.getOutcomeElement(), -1); 2858 } 2859 if (element.hasOutcomeDescElement()) { 2860 composeString(t, "AuditEvent", "outcomeDesc", element.getOutcomeDescElement(), -1); 2861 } 2862 for (int i = 0; i < element.getPurposeOfEvent().size(); i++) { 2863 composeCodeableConcept(t, "AuditEvent", "purposeOfEvent", element.getPurposeOfEvent().get(i), i); 2864 } 2865 for (int i = 0; i < element.getAgent().size(); i++) { 2866 composeAuditEventAgentComponent(t, "AuditEvent", "agent", element.getAgent().get(i), i); 2867 } 2868 if (element.hasSource()) { 2869 composeAuditEventSourceComponent(t, "AuditEvent", "source", element.getSource(), -1); 2870 } 2871 for (int i = 0; i < element.getEntity().size(); i++) { 2872 composeAuditEventEntityComponent(t, "AuditEvent", "entity", element.getEntity().get(i), i); 2873 } 2874 } 2875 2876 protected void composeAuditEventAgentComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentComponent element, int index) { 2877 if (element == null) 2878 return; 2879 Complex t; 2880 if (Utilities.noString(parentType)) 2881 t = parent; 2882 else { 2883 t = parent.predicate("fhir:"+parentType+'.'+name); 2884 } 2885 composeBackboneElement(t, "agent", name, element, index); 2886 if (element.hasType()) { 2887 composeCodeableConcept(t, "AuditEventAgentComponent", "type", element.getType(), -1); 2888 } 2889 for (int i = 0; i < element.getRole().size(); i++) { 2890 composeCodeableConcept(t, "AuditEventAgentComponent", "role", element.getRole().get(i), i); 2891 } 2892 if (element.hasWho()) { 2893 composeReference(t, "AuditEventAgentComponent", "who", element.getWho(), -1); 2894 } 2895 if (element.hasAltIdElement()) { 2896 composeString(t, "AuditEventAgentComponent", "altId", element.getAltIdElement(), -1); 2897 } 2898 if (element.hasNameElement()) { 2899 composeString(t, "AuditEventAgentComponent", "name", element.getNameElement(), -1); 2900 } 2901 if (element.hasRequestorElement()) { 2902 composeBoolean(t, "AuditEventAgentComponent", "requestor", element.getRequestorElement(), -1); 2903 } 2904 if (element.hasLocation()) { 2905 composeReference(t, "AuditEventAgentComponent", "location", element.getLocation(), -1); 2906 } 2907 for (int i = 0; i < element.getPolicy().size(); i++) { 2908 composeUri(t, "AuditEventAgentComponent", "policy", element.getPolicy().get(i), i); 2909 } 2910 if (element.hasMedia()) { 2911 composeCoding(t, "AuditEventAgentComponent", "media", element.getMedia(), -1); 2912 } 2913 if (element.hasNetwork()) { 2914 composeAuditEventAgentNetworkComponent(t, "AuditEventAgentComponent", "network", element.getNetwork(), -1); 2915 } 2916 for (int i = 0; i < element.getPurposeOfUse().size(); i++) { 2917 composeCodeableConcept(t, "AuditEventAgentComponent", "purposeOfUse", element.getPurposeOfUse().get(i), i); 2918 } 2919 } 2920 2921 protected void composeAuditEventAgentNetworkComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentNetworkComponent element, int index) { 2922 if (element == null) 2923 return; 2924 Complex t; 2925 if (Utilities.noString(parentType)) 2926 t = parent; 2927 else { 2928 t = parent.predicate("fhir:"+parentType+'.'+name); 2929 } 2930 composeBackboneElement(t, "network", name, element, index); 2931 if (element.hasAddressElement()) { 2932 composeString(t, "AuditEventAgentNetworkComponent", "address", element.getAddressElement(), -1); 2933 } 2934 if (element.hasTypeElement()) { 2935 composeEnum(t, "AuditEventAgentNetworkComponent", "type", element.getTypeElement(), -1); 2936 } 2937 } 2938 2939 protected void composeAuditEventSourceComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventSourceComponent element, int index) { 2940 if (element == null) 2941 return; 2942 Complex t; 2943 if (Utilities.noString(parentType)) 2944 t = parent; 2945 else { 2946 t = parent.predicate("fhir:"+parentType+'.'+name); 2947 } 2948 composeBackboneElement(t, "source", name, element, index); 2949 if (element.hasSiteElement()) { 2950 composeString(t, "AuditEventSourceComponent", "site", element.getSiteElement(), -1); 2951 } 2952 if (element.hasObserver()) { 2953 composeReference(t, "AuditEventSourceComponent", "observer", element.getObserver(), -1); 2954 } 2955 for (int i = 0; i < element.getType().size(); i++) { 2956 composeCoding(t, "AuditEventSourceComponent", "type", element.getType().get(i), i); 2957 } 2958 } 2959 2960 protected void composeAuditEventEntityComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityComponent 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 composeBackboneElement(t, "entity", name, element, index); 2970 if (element.hasWhat()) { 2971 composeReference(t, "AuditEventEntityComponent", "what", element.getWhat(), -1); 2972 } 2973 if (element.hasType()) { 2974 composeCoding(t, "AuditEventEntityComponent", "type", element.getType(), -1); 2975 } 2976 if (element.hasRole()) { 2977 composeCoding(t, "AuditEventEntityComponent", "role", element.getRole(), -1); 2978 } 2979 if (element.hasLifecycle()) { 2980 composeCoding(t, "AuditEventEntityComponent", "lifecycle", element.getLifecycle(), -1); 2981 } 2982 for (int i = 0; i < element.getSecurityLabel().size(); i++) { 2983 composeCoding(t, "AuditEventEntityComponent", "securityLabel", element.getSecurityLabel().get(i), i); 2984 } 2985 if (element.hasNameElement()) { 2986 composeString(t, "AuditEventEntityComponent", "name", element.getNameElement(), -1); 2987 } 2988 if (element.hasQueryElement()) { 2989 composeBase64Binary(t, "AuditEventEntityComponent", "query", element.getQueryElement(), -1); 2990 } 2991 for (int i = 0; i < element.getDetail().size(); i++) { 2992 composeAuditEventEntityDetailComponent(t, "AuditEventEntityComponent", "detail", element.getDetail().get(i), i); 2993 } 2994 } 2995 2996 protected void composeAuditEventEntityDetailComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityDetailComponent element, int index) { 2997 if (element == null) 2998 return; 2999 Complex t; 3000 if (Utilities.noString(parentType)) 3001 t = parent; 3002 else { 3003 t = parent.predicate("fhir:"+parentType+'.'+name); 3004 } 3005 composeBackboneElement(t, "detail", name, element, index); 3006 if (element.hasTypeElement()) { 3007 composeString(t, "AuditEventEntityDetailComponent", "type", element.getTypeElement(), -1); 3008 } 3009 if (element.hasValue()) { 3010 composeType(t, "AuditEventEntityDetailComponent", "value", element.getValue(), -1); 3011 } 3012 } 3013 3014 protected void composeBasic(Complex parent, String parentType, String name, Basic element, int index) { 3015 if (element == null) 3016 return; 3017 Complex t; 3018 if (Utilities.noString(parentType)) 3019 t = parent; 3020 else { 3021 t = parent.predicate("fhir:"+parentType+'.'+name); 3022 } 3023 composeDomainResource(t, "Basic", name, element, index); 3024 for (int i = 0; i < element.getIdentifier().size(); i++) { 3025 composeIdentifier(t, "Basic", "identifier", element.getIdentifier().get(i), i); 3026 } 3027 if (element.hasCode()) { 3028 composeCodeableConcept(t, "Basic", "code", element.getCode(), -1); 3029 } 3030 if (element.hasSubject()) { 3031 composeReference(t, "Basic", "subject", element.getSubject(), -1); 3032 } 3033 if (element.hasCreatedElement()) { 3034 composeDate(t, "Basic", "created", element.getCreatedElement(), -1); 3035 } 3036 if (element.hasAuthor()) { 3037 composeReference(t, "Basic", "author", element.getAuthor(), -1); 3038 } 3039 } 3040 3041 protected void composeBinary(Complex parent, String parentType, String name, Binary element, int index) { 3042 if (element == null) 3043 return; 3044 Complex t; 3045 if (Utilities.noString(parentType)) 3046 t = parent; 3047 else { 3048 t = parent.predicate("fhir:"+parentType+'.'+name); 3049 } 3050 composeResource(t, "Binary", name, element, index); 3051 if (element.hasContentTypeElement()) { 3052 composeCode(t, "Binary", "contentType", element.getContentTypeElement(), -1); 3053 } 3054 if (element.hasSecurityContext()) { 3055 composeReference(t, "Binary", "securityContext", element.getSecurityContext(), -1); 3056 } 3057 if (element.hasDataElement()) { 3058 composeBase64Binary(t, "Binary", "data", element.getDataElement(), -1); 3059 } 3060 } 3061 3062 protected void composeBiologicallyDerivedProduct(Complex parent, String parentType, String name, BiologicallyDerivedProduct element, int index) { 3063 if (element == null) 3064 return; 3065 Complex t; 3066 if (Utilities.noString(parentType)) 3067 t = parent; 3068 else { 3069 t = parent.predicate("fhir:"+parentType+'.'+name); 3070 } 3071 composeDomainResource(t, "BiologicallyDerivedProduct", name, element, index); 3072 for (int i = 0; i < element.getIdentifier().size(); i++) { 3073 composeIdentifier(t, "BiologicallyDerivedProduct", "identifier", element.getIdentifier().get(i), i); 3074 } 3075 if (element.hasProductCategoryElement()) { 3076 composeEnum(t, "BiologicallyDerivedProduct", "productCategory", element.getProductCategoryElement(), -1); 3077 } 3078 if (element.hasProductCode()) { 3079 composeCodeableConcept(t, "BiologicallyDerivedProduct", "productCode", element.getProductCode(), -1); 3080 } 3081 if (element.hasStatusElement()) { 3082 composeEnum(t, "BiologicallyDerivedProduct", "status", element.getStatusElement(), -1); 3083 } 3084 for (int i = 0; i < element.getRequest().size(); i++) { 3085 composeReference(t, "BiologicallyDerivedProduct", "request", element.getRequest().get(i), i); 3086 } 3087 if (element.hasQuantityElement()) { 3088 composeInteger(t, "BiologicallyDerivedProduct", "quantity", element.getQuantityElement(), -1); 3089 } 3090 for (int i = 0; i < element.getParent().size(); i++) { 3091 composeReference(t, "BiologicallyDerivedProduct", "parent", element.getParent().get(i), i); 3092 } 3093 if (element.hasCollection()) { 3094 composeBiologicallyDerivedProductCollectionComponent(t, "BiologicallyDerivedProduct", "collection", element.getCollection(), -1); 3095 } 3096 for (int i = 0; i < element.getProcessing().size(); i++) { 3097 composeBiologicallyDerivedProductProcessingComponent(t, "BiologicallyDerivedProduct", "processing", element.getProcessing().get(i), i); 3098 } 3099 if (element.hasManipulation()) { 3100 composeBiologicallyDerivedProductManipulationComponent(t, "BiologicallyDerivedProduct", "manipulation", element.getManipulation(), -1); 3101 } 3102 for (int i = 0; i < element.getStorage().size(); i++) { 3103 composeBiologicallyDerivedProductStorageComponent(t, "BiologicallyDerivedProduct", "storage", element.getStorage().get(i), i); 3104 } 3105 } 3106 3107 protected void composeBiologicallyDerivedProductCollectionComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductCollectionComponent element, int index) { 3108 if (element == null) 3109 return; 3110 Complex t; 3111 if (Utilities.noString(parentType)) 3112 t = parent; 3113 else { 3114 t = parent.predicate("fhir:"+parentType+'.'+name); 3115 } 3116 composeBackboneElement(t, "collection", name, element, index); 3117 if (element.hasCollector()) { 3118 composeReference(t, "BiologicallyDerivedProductCollectionComponent", "collector", element.getCollector(), -1); 3119 } 3120 if (element.hasSource()) { 3121 composeReference(t, "BiologicallyDerivedProductCollectionComponent", "source", element.getSource(), -1); 3122 } 3123 if (element.hasCollected()) { 3124 composeType(t, "BiologicallyDerivedProductCollectionComponent", "collected", element.getCollected(), -1); 3125 } 3126 } 3127 3128 protected void composeBiologicallyDerivedProductProcessingComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductProcessingComponent element, int index) { 3129 if (element == null) 3130 return; 3131 Complex t; 3132 if (Utilities.noString(parentType)) 3133 t = parent; 3134 else { 3135 t = parent.predicate("fhir:"+parentType+'.'+name); 3136 } 3137 composeBackboneElement(t, "processing", name, element, index); 3138 if (element.hasDescriptionElement()) { 3139 composeString(t, "BiologicallyDerivedProductProcessingComponent", "description", element.getDescriptionElement(), -1); 3140 } 3141 if (element.hasProcedure()) { 3142 composeCodeableConcept(t, "BiologicallyDerivedProductProcessingComponent", "procedure", element.getProcedure(), -1); 3143 } 3144 if (element.hasAdditive()) { 3145 composeReference(t, "BiologicallyDerivedProductProcessingComponent", "additive", element.getAdditive(), -1); 3146 } 3147 if (element.hasTime()) { 3148 composeType(t, "BiologicallyDerivedProductProcessingComponent", "time", element.getTime(), -1); 3149 } 3150 } 3151 3152 protected void composeBiologicallyDerivedProductManipulationComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductManipulationComponent 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 composeBackboneElement(t, "manipulation", name, element, index); 3162 if (element.hasDescriptionElement()) { 3163 composeString(t, "BiologicallyDerivedProductManipulationComponent", "description", element.getDescriptionElement(), -1); 3164 } 3165 if (element.hasTime()) { 3166 composeType(t, "BiologicallyDerivedProductManipulationComponent", "time", element.getTime(), -1); 3167 } 3168 } 3169 3170 protected void composeBiologicallyDerivedProductStorageComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductStorageComponent element, int index) { 3171 if (element == null) 3172 return; 3173 Complex t; 3174 if (Utilities.noString(parentType)) 3175 t = parent; 3176 else { 3177 t = parent.predicate("fhir:"+parentType+'.'+name); 3178 } 3179 composeBackboneElement(t, "storage", name, element, index); 3180 if (element.hasDescriptionElement()) { 3181 composeString(t, "BiologicallyDerivedProductStorageComponent", "description", element.getDescriptionElement(), -1); 3182 } 3183 if (element.hasTemperatureElement()) { 3184 composeDecimal(t, "BiologicallyDerivedProductStorageComponent", "temperature", element.getTemperatureElement(), -1); 3185 } 3186 if (element.hasScaleElement()) { 3187 composeEnum(t, "BiologicallyDerivedProductStorageComponent", "scale", element.getScaleElement(), -1); 3188 } 3189 if (element.hasDuration()) { 3190 composePeriod(t, "BiologicallyDerivedProductStorageComponent", "duration", element.getDuration(), -1); 3191 } 3192 } 3193 3194 protected void composeBodyStructure(Complex parent, String parentType, String name, BodyStructure element, int index) { 3195 if (element == null) 3196 return; 3197 Complex t; 3198 if (Utilities.noString(parentType)) 3199 t = parent; 3200 else { 3201 t = parent.predicate("fhir:"+parentType+'.'+name); 3202 } 3203 composeDomainResource(t, "BodyStructure", name, element, index); 3204 for (int i = 0; i < element.getIdentifier().size(); i++) { 3205 composeIdentifier(t, "BodyStructure", "identifier", element.getIdentifier().get(i), i); 3206 } 3207 if (element.hasActiveElement()) { 3208 composeBoolean(t, "BodyStructure", "active", element.getActiveElement(), -1); 3209 } 3210 if (element.hasMorphology()) { 3211 composeCodeableConcept(t, "BodyStructure", "morphology", element.getMorphology(), -1); 3212 } 3213 if (element.hasLocation()) { 3214 composeCodeableConcept(t, "BodyStructure", "location", element.getLocation(), -1); 3215 } 3216 for (int i = 0; i < element.getLocationQualifier().size(); i++) { 3217 composeCodeableConcept(t, "BodyStructure", "locationQualifier", element.getLocationQualifier().get(i), i); 3218 } 3219 if (element.hasDescriptionElement()) { 3220 composeString(t, "BodyStructure", "description", element.getDescriptionElement(), -1); 3221 } 3222 for (int i = 0; i < element.getImage().size(); i++) { 3223 composeAttachment(t, "BodyStructure", "image", element.getImage().get(i), i); 3224 } 3225 if (element.hasPatient()) { 3226 composeReference(t, "BodyStructure", "patient", element.getPatient(), -1); 3227 } 3228 } 3229 3230 protected void composeBundle(Complex parent, String parentType, String name, Bundle element, int index) { 3231 if (element == null) 3232 return; 3233 Complex t; 3234 if (Utilities.noString(parentType)) 3235 t = parent; 3236 else { 3237 t = parent.predicate("fhir:"+parentType+'.'+name); 3238 } 3239 composeResource(t, "Bundle", name, element, index); 3240 if (element.hasIdentifier()) { 3241 composeIdentifier(t, "Bundle", "identifier", element.getIdentifier(), -1); 3242 } 3243 if (element.hasTypeElement()) { 3244 composeEnum(t, "Bundle", "type", element.getTypeElement(), -1); 3245 } 3246 if (element.hasTimestampElement()) { 3247 composeInstant(t, "Bundle", "timestamp", element.getTimestampElement(), -1); 3248 } 3249 if (element.hasTotalElement()) { 3250 composeUnsignedInt(t, "Bundle", "total", element.getTotalElement(), -1); 3251 } 3252 for (int i = 0; i < element.getLink().size(); i++) { 3253 composeBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i); 3254 } 3255 for (int i = 0; i < element.getEntry().size(); i++) { 3256 composeBundleEntryComponent(t, "Bundle", "entry", element.getEntry().get(i), i); 3257 } 3258 if (element.hasSignature()) { 3259 composeSignature(t, "Bundle", "signature", element.getSignature(), -1); 3260 } 3261 } 3262 3263 protected void composeBundleLinkComponent(Complex parent, String parentType, String name, Bundle.BundleLinkComponent element, int index) { 3264 if (element == null) 3265 return; 3266 Complex t; 3267 if (Utilities.noString(parentType)) 3268 t = parent; 3269 else { 3270 t = parent.predicate("fhir:"+parentType+'.'+name); 3271 } 3272 composeBackboneElement(t, "link", name, element, index); 3273 if (element.hasRelationElement()) { 3274 composeString(t, "BundleLinkComponent", "relation", element.getRelationElement(), -1); 3275 } 3276 if (element.hasUrlElement()) { 3277 composeUri(t, "BundleLinkComponent", "url", element.getUrlElement(), -1); 3278 } 3279 } 3280 3281 protected void composeBundleEntryComponent(Complex parent, String parentType, String name, Bundle.BundleEntryComponent element, int index) { 3282 if (element == null) 3283 return; 3284 Complex t; 3285 if (Utilities.noString(parentType)) 3286 t = parent; 3287 else { 3288 t = parent.predicate("fhir:"+parentType+'.'+name); 3289 } 3290 composeBackboneElement(t, "entry", name, element, index); 3291 for (int i = 0; i < element.getLink().size(); i++) { 3292 composeBundleLinkComponent(t, "BundleEntryComponent", "link", element.getLink().get(i), i); 3293 } 3294 if (element.hasFullUrlElement()) { 3295 composeUri(t, "BundleEntryComponent", "fullUrl", element.getFullUrlElement(), -1); 3296 } 3297 if (element.hasResource()) { 3298 composeResource(t, "BundleEntryComponent", "resource", element.getResource(), -1); 3299 } 3300 if (element.hasSearch()) { 3301 composeBundleEntrySearchComponent(t, "BundleEntryComponent", "search", element.getSearch(), -1); 3302 } 3303 if (element.hasRequest()) { 3304 composeBundleEntryRequestComponent(t, "BundleEntryComponent", "request", element.getRequest(), -1); 3305 } 3306 if (element.hasResponse()) { 3307 composeBundleEntryResponseComponent(t, "BundleEntryComponent", "response", element.getResponse(), -1); 3308 } 3309 } 3310 3311 protected void composeBundleEntrySearchComponent(Complex parent, String parentType, String name, Bundle.BundleEntrySearchComponent element, int index) { 3312 if (element == null) 3313 return; 3314 Complex t; 3315 if (Utilities.noString(parentType)) 3316 t = parent; 3317 else { 3318 t = parent.predicate("fhir:"+parentType+'.'+name); 3319 } 3320 composeBackboneElement(t, "search", name, element, index); 3321 if (element.hasModeElement()) { 3322 composeEnum(t, "BundleEntrySearchComponent", "mode", element.getModeElement(), -1); 3323 } 3324 if (element.hasScoreElement()) { 3325 composeDecimal(t, "BundleEntrySearchComponent", "score", element.getScoreElement(), -1); 3326 } 3327 } 3328 3329 protected void composeBundleEntryRequestComponent(Complex parent, String parentType, String name, Bundle.BundleEntryRequestComponent element, int index) { 3330 if (element == null) 3331 return; 3332 Complex t; 3333 if (Utilities.noString(parentType)) 3334 t = parent; 3335 else { 3336 t = parent.predicate("fhir:"+parentType+'.'+name); 3337 } 3338 composeBackboneElement(t, "request", name, element, index); 3339 if (element.hasMethodElement()) { 3340 composeEnum(t, "BundleEntryRequestComponent", "method", element.getMethodElement(), -1); 3341 } 3342 if (element.hasUrlElement()) { 3343 composeUri(t, "BundleEntryRequestComponent", "url", element.getUrlElement(), -1); 3344 } 3345 if (element.hasIfNoneMatchElement()) { 3346 composeString(t, "BundleEntryRequestComponent", "ifNoneMatch", element.getIfNoneMatchElement(), -1); 3347 } 3348 if (element.hasIfModifiedSinceElement()) { 3349 composeInstant(t, "BundleEntryRequestComponent", "ifModifiedSince", element.getIfModifiedSinceElement(), -1); 3350 } 3351 if (element.hasIfMatchElement()) { 3352 composeString(t, "BundleEntryRequestComponent", "ifMatch", element.getIfMatchElement(), -1); 3353 } 3354 if (element.hasIfNoneExistElement()) { 3355 composeString(t, "BundleEntryRequestComponent", "ifNoneExist", element.getIfNoneExistElement(), -1); 3356 } 3357 } 3358 3359 protected void composeBundleEntryResponseComponent(Complex parent, String parentType, String name, Bundle.BundleEntryResponseComponent element, int index) { 3360 if (element == null) 3361 return; 3362 Complex t; 3363 if (Utilities.noString(parentType)) 3364 t = parent; 3365 else { 3366 t = parent.predicate("fhir:"+parentType+'.'+name); 3367 } 3368 composeBackboneElement(t, "response", name, element, index); 3369 if (element.hasStatusElement()) { 3370 composeString(t, "BundleEntryResponseComponent", "status", element.getStatusElement(), -1); 3371 } 3372 if (element.hasLocationElement()) { 3373 composeUri(t, "BundleEntryResponseComponent", "location", element.getLocationElement(), -1); 3374 } 3375 if (element.hasEtagElement()) { 3376 composeString(t, "BundleEntryResponseComponent", "etag", element.getEtagElement(), -1); 3377 } 3378 if (element.hasLastModifiedElement()) { 3379 composeInstant(t, "BundleEntryResponseComponent", "lastModified", element.getLastModifiedElement(), -1); 3380 } 3381 if (element.hasOutcome()) { 3382 composeResource(t, "BundleEntryResponseComponent", "outcome", element.getOutcome(), -1); 3383 } 3384 } 3385 3386 protected void composeCapabilityStatement(Complex parent, String parentType, String name, CapabilityStatement 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 composeCanonicalResource(t, "CapabilityStatement", name, element, index); 3396 if (element.hasUrlElement()) { 3397 composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1); 3398 } 3399 if (element.hasVersionElement()) { 3400 composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1); 3401 } 3402 if (element.hasNameElement()) { 3403 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 3404 } 3405 if (element.hasTitleElement()) { 3406 composeString(t, "CapabilityStatement", "title", element.getTitleElement(), -1); 3407 } 3408 if (element.hasStatusElement()) { 3409 composeEnum(t, "CapabilityStatement", "status", element.getStatusElement(), -1); 3410 } 3411 if (element.hasExperimentalElement()) { 3412 composeBoolean(t, "CapabilityStatement", "experimental", element.getExperimentalElement(), -1); 3413 } 3414 if (element.hasDateElement()) { 3415 composeDateTime(t, "CapabilityStatement", "date", element.getDateElement(), -1); 3416 } 3417 if (element.hasPublisherElement()) { 3418 composeString(t, "CapabilityStatement", "publisher", element.getPublisherElement(), -1); 3419 } 3420 for (int i = 0; i < element.getContact().size(); i++) { 3421 composeContactDetail(t, "CapabilityStatement", "contact", element.getContact().get(i), i); 3422 } 3423 if (element.hasDescriptionElement()) { 3424 composeMarkdown(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1); 3425 } 3426 for (int i = 0; i < element.getUseContext().size(); i++) { 3427 composeUsageContext(t, "CapabilityStatement", "useContext", element.getUseContext().get(i), i); 3428 } 3429 for (int i = 0; i < element.getJurisdiction().size(); i++) { 3430 composeCodeableConcept(t, "CapabilityStatement", "jurisdiction", element.getJurisdiction().get(i), i); 3431 } 3432 if (element.hasPurposeElement()) { 3433 composeMarkdown(t, "CapabilityStatement", "purpose", element.getPurposeElement(), -1); 3434 } 3435 if (element.hasCopyrightElement()) { 3436 composeMarkdown(t, "CapabilityStatement", "copyright", element.getCopyrightElement(), -1); 3437 } 3438 if (element.hasKindElement()) { 3439 composeEnum(t, "CapabilityStatement", "kind", element.getKindElement(), -1); 3440 } 3441 for (int i = 0; i < element.getInstantiates().size(); i++) { 3442 composeCanonical(t, "CapabilityStatement", "instantiates", element.getInstantiates().get(i), i); 3443 } 3444 for (int i = 0; i < element.getImports().size(); i++) { 3445 composeCanonical(t, "CapabilityStatement", "imports", element.getImports().get(i), i); 3446 } 3447 if (element.hasSoftware()) { 3448 composeCapabilityStatementSoftwareComponent(t, "CapabilityStatement", "software", element.getSoftware(), -1); 3449 } 3450 if (element.hasImplementation()) { 3451 composeCapabilityStatementImplementationComponent(t, "CapabilityStatement", "implementation", element.getImplementation(), -1); 3452 } 3453 if (element.hasFhirVersionElement()) { 3454 composeEnum(t, "CapabilityStatement", "fhirVersion", element.getFhirVersionElement(), -1); 3455 } 3456 for (int i = 0; i < element.getFormat().size(); i++) { 3457 composeCode(t, "CapabilityStatement", "format", element.getFormat().get(i), i); 3458 } 3459 for (int i = 0; i < element.getPatchFormat().size(); i++) { 3460 composeCode(t, "CapabilityStatement", "patchFormat", element.getPatchFormat().get(i), i); 3461 } 3462 for (int i = 0; i < element.getImplementationGuide().size(); i++) { 3463 composeCanonical(t, "CapabilityStatement", "implementationGuide", element.getImplementationGuide().get(i), i); 3464 } 3465 for (int i = 0; i < element.getRest().size(); i++) { 3466 composeCapabilityStatementRestComponent(t, "CapabilityStatement", "rest", element.getRest().get(i), i); 3467 } 3468 for (int i = 0; i < element.getMessaging().size(); i++) { 3469 composeCapabilityStatementMessagingComponent(t, "CapabilityStatement", "messaging", element.getMessaging().get(i), i); 3470 } 3471 for (int i = 0; i < element.getDocument().size(); i++) { 3472 composeCapabilityStatementDocumentComponent(t, "CapabilityStatement", "document", element.getDocument().get(i), i); 3473 } 3474 } 3475 3476 protected void composeCapabilityStatementSoftwareComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementSoftwareComponent 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, "software", name, element, index); 3486 if (element.hasNameElement()) { 3487 composeString(t, "CapabilityStatementSoftwareComponent", "name", element.getNameElement(), -1); 3488 } 3489 if (element.hasVersionElement()) { 3490 composeString(t, "CapabilityStatementSoftwareComponent", "version", element.getVersionElement(), -1); 3491 } 3492 if (element.hasReleaseDateElement()) { 3493 composeDateTime(t, "CapabilityStatementSoftwareComponent", "releaseDate", element.getReleaseDateElement(), -1); 3494 } 3495 } 3496 3497 protected void composeCapabilityStatementImplementationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementImplementationComponent element, int index) { 3498 if (element == null) 3499 return; 3500 Complex t; 3501 if (Utilities.noString(parentType)) 3502 t = parent; 3503 else { 3504 t = parent.predicate("fhir:"+parentType+'.'+name); 3505 } 3506 composeBackboneElement(t, "implementation", name, element, index); 3507 if (element.hasDescriptionElement()) { 3508 composeString(t, "CapabilityStatementImplementationComponent", "description", element.getDescriptionElement(), -1); 3509 } 3510 if (element.hasUrlElement()) { 3511 composeUrl(t, "CapabilityStatementImplementationComponent", "url", element.getUrlElement(), -1); 3512 } 3513 if (element.hasCustodian()) { 3514 composeReference(t, "CapabilityStatementImplementationComponent", "custodian", element.getCustodian(), -1); 3515 } 3516 } 3517 3518 protected void composeCapabilityStatementRestComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestComponent element, int index) { 3519 if (element == null) 3520 return; 3521 Complex t; 3522 if (Utilities.noString(parentType)) 3523 t = parent; 3524 else { 3525 t = parent.predicate("fhir:"+parentType+'.'+name); 3526 } 3527 composeBackboneElement(t, "rest", name, element, index); 3528 if (element.hasModeElement()) { 3529 composeEnum(t, "CapabilityStatementRestComponent", "mode", element.getModeElement(), -1); 3530 } 3531 if (element.hasDocumentationElement()) { 3532 composeMarkdown(t, "CapabilityStatementRestComponent", "documentation", element.getDocumentationElement(), -1); 3533 } 3534 if (element.hasSecurity()) { 3535 composeCapabilityStatementRestSecurityComponent(t, "CapabilityStatementRestComponent", "security", element.getSecurity(), -1); 3536 } 3537 for (int i = 0; i < element.getResource().size(); i++) { 3538 composeCapabilityStatementRestResourceComponent(t, "CapabilityStatementRestComponent", "resource", element.getResource().get(i), i); 3539 } 3540 for (int i = 0; i < element.getInteraction().size(); i++) { 3541 composeCapabilityStatementSystemInteractionComponent(t, "CapabilityStatementRestComponent", "interaction", element.getInteraction().get(i), i); 3542 } 3543 for (int i = 0; i < element.getSearchParam().size(); i++) { 3544 composeCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatementRestComponent", "searchParam", element.getSearchParam().get(i), i); 3545 } 3546 for (int i = 0; i < element.getOperation().size(); i++) { 3547 composeCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatementRestComponent", "operation", element.getOperation().get(i), i); 3548 } 3549 for (int i = 0; i < element.getCompartment().size(); i++) { 3550 composeCanonical(t, "CapabilityStatementRestComponent", "compartment", element.getCompartment().get(i), i); 3551 } 3552 } 3553 3554 protected void composeCapabilityStatementRestSecurityComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityComponent element, int index) { 3555 if (element == null) 3556 return; 3557 Complex t; 3558 if (Utilities.noString(parentType)) 3559 t = parent; 3560 else { 3561 t = parent.predicate("fhir:"+parentType+'.'+name); 3562 } 3563 composeBackboneElement(t, "security", name, element, index); 3564 if (element.hasCorsElement()) { 3565 composeBoolean(t, "CapabilityStatementRestSecurityComponent", "cors", element.getCorsElement(), -1); 3566 } 3567 for (int i = 0; i < element.getService().size(); i++) { 3568 composeCodeableConcept(t, "CapabilityStatementRestSecurityComponent", "service", element.getService().get(i), i); 3569 } 3570 if (element.hasDescriptionElement()) { 3571 composeMarkdown(t, "CapabilityStatementRestSecurityComponent", "description", element.getDescriptionElement(), -1); 3572 } 3573 } 3574 3575 protected void composeCapabilityStatementRestResourceComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceComponent element, int index) { 3576 if (element == null) 3577 return; 3578 Complex t; 3579 if (Utilities.noString(parentType)) 3580 t = parent; 3581 else { 3582 t = parent.predicate("fhir:"+parentType+'.'+name); 3583 } 3584 composeBackboneElement(t, "resource", name, element, index); 3585 if (element.hasTypeElement()) { 3586 composeCode(t, "CapabilityStatementRestResourceComponent", "type", element.getTypeElement(), -1); 3587 } 3588 if (element.hasProfileElement()) { 3589 composeCanonical(t, "CapabilityStatementRestResourceComponent", "profile", element.getProfileElement(), -1); 3590 } 3591 for (int i = 0; i < element.getSupportedProfile().size(); i++) { 3592 composeCanonical(t, "CapabilityStatementRestResourceComponent", "supportedProfile", element.getSupportedProfile().get(i), i); 3593 } 3594 if (element.hasDocumentationElement()) { 3595 composeMarkdown(t, "CapabilityStatementRestResourceComponent", "documentation", element.getDocumentationElement(), -1); 3596 } 3597 for (int i = 0; i < element.getInteraction().size(); i++) { 3598 composeCapabilityStatementResourceInteractionComponent(t, "CapabilityStatementRestResourceComponent", "interaction", element.getInteraction().get(i), i); 3599 } 3600 if (element.hasVersioningElement()) { 3601 composeEnum(t, "CapabilityStatementRestResourceComponent", "versioning", element.getVersioningElement(), -1); 3602 } 3603 if (element.hasReadHistoryElement()) { 3604 composeBoolean(t, "CapabilityStatementRestResourceComponent", "readHistory", element.getReadHistoryElement(), -1); 3605 } 3606 if (element.hasUpdateCreateElement()) { 3607 composeBoolean(t, "CapabilityStatementRestResourceComponent", "updateCreate", element.getUpdateCreateElement(), -1); 3608 } 3609 if (element.hasConditionalCreateElement()) { 3610 composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalCreate", element.getConditionalCreateElement(), -1); 3611 } 3612 if (element.hasConditionalReadElement()) { 3613 composeEnum(t, "CapabilityStatementRestResourceComponent", "conditionalRead", element.getConditionalReadElement(), -1); 3614 } 3615 if (element.hasConditionalUpdateElement()) { 3616 composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalUpdate", element.getConditionalUpdateElement(), -1); 3617 } 3618 if (element.hasConditionalDeleteElement()) { 3619 composeEnum(t, "CapabilityStatementRestResourceComponent", "conditionalDelete", element.getConditionalDeleteElement(), -1); 3620 } 3621 for (int i = 0; i < element.getReferencePolicy().size(); i++) { 3622 composeEnum(t, "CapabilityStatementRestResourceComponent", "referencePolicy", element.getReferencePolicy().get(i), i); 3623 } 3624 for (int i = 0; i < element.getSearchInclude().size(); i++) { 3625 composeString(t, "CapabilityStatementRestResourceComponent", "searchInclude", element.getSearchInclude().get(i), i); 3626 } 3627 for (int i = 0; i < element.getSearchRevInclude().size(); i++) { 3628 composeString(t, "CapabilityStatementRestResourceComponent", "searchRevInclude", element.getSearchRevInclude().get(i), i); 3629 } 3630 for (int i = 0; i < element.getSearchParam().size(); i++) { 3631 composeCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatementRestResourceComponent", "searchParam", element.getSearchParam().get(i), i); 3632 } 3633 for (int i = 0; i < element.getOperation().size(); i++) { 3634 composeCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatementRestResourceComponent", "operation", element.getOperation().get(i), i); 3635 } 3636 } 3637 3638 protected void composeCapabilityStatementResourceInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.ResourceInteractionComponent element, int index) { 3639 if (element == null) 3640 return; 3641 Complex t; 3642 if (Utilities.noString(parentType)) 3643 t = parent; 3644 else { 3645 t = parent.predicate("fhir:"+parentType+'.'+name); 3646 } 3647 composeBackboneElement(t, "interaction", name, element, index); 3648 if (element.hasCodeElement()) { 3649 composeEnum(t, "ResourceInteractionComponent", "code", element.getCodeElement(), -1); 3650 } 3651 if (element.hasDocumentationElement()) { 3652 composeMarkdown(t, "ResourceInteractionComponent", "documentation", element.getDocumentationElement(), -1); 3653 } 3654 } 3655 3656 protected void composeCapabilityStatementRestResourceSearchParamComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent element, int index) { 3657 if (element == null) 3658 return; 3659 Complex t; 3660 if (Utilities.noString(parentType)) 3661 t = parent; 3662 else { 3663 t = parent.predicate("fhir:"+parentType+'.'+name); 3664 } 3665 composeBackboneElement(t, "searchParam", name, element, index); 3666 if (element.hasNameElement()) { 3667 composeString(t, "CapabilityStatementRestResourceSearchParamComponent", "name", element.getNameElement(), -1); 3668 } 3669 if (element.hasDefinitionElement()) { 3670 composeCanonical(t, "CapabilityStatementRestResourceSearchParamComponent", "definition", element.getDefinitionElement(), -1); 3671 } 3672 if (element.hasTypeElement()) { 3673 composeEnum(t, "CapabilityStatementRestResourceSearchParamComponent", "type", element.getTypeElement(), -1); 3674 } 3675 if (element.hasDocumentationElement()) { 3676 composeMarkdown(t, "CapabilityStatementRestResourceSearchParamComponent", "documentation", element.getDocumentationElement(), -1); 3677 } 3678 } 3679 3680 protected void composeCapabilityStatementRestResourceOperationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceOperationComponent element, int index) { 3681 if (element == null) 3682 return; 3683 Complex t; 3684 if (Utilities.noString(parentType)) 3685 t = parent; 3686 else { 3687 t = parent.predicate("fhir:"+parentType+'.'+name); 3688 } 3689 composeBackboneElement(t, "operation", name, element, index); 3690 if (element.hasNameElement()) { 3691 composeString(t, "CapabilityStatementRestResourceOperationComponent", "name", element.getNameElement(), -1); 3692 } 3693 if (element.hasDefinitionElement()) { 3694 composeCanonical(t, "CapabilityStatementRestResourceOperationComponent", "definition", element.getDefinitionElement(), -1); 3695 } 3696 if (element.hasDocumentationElement()) { 3697 composeMarkdown(t, "CapabilityStatementRestResourceOperationComponent", "documentation", element.getDocumentationElement(), -1); 3698 } 3699 } 3700 3701 protected void composeCapabilityStatementSystemInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.SystemInteractionComponent element, int index) { 3702 if (element == null) 3703 return; 3704 Complex t; 3705 if (Utilities.noString(parentType)) 3706 t = parent; 3707 else { 3708 t = parent.predicate("fhir:"+parentType+'.'+name); 3709 } 3710 composeBackboneElement(t, "interaction", name, element, index); 3711 if (element.hasCodeElement()) { 3712 composeEnum(t, "SystemInteractionComponent", "code", element.getCodeElement(), -1); 3713 } 3714 if (element.hasDocumentationElement()) { 3715 composeMarkdown(t, "SystemInteractionComponent", "documentation", element.getDocumentationElement(), -1); 3716 } 3717 } 3718 3719 protected void composeCapabilityStatementMessagingComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingComponent element, int index) { 3720 if (element == null) 3721 return; 3722 Complex t; 3723 if (Utilities.noString(parentType)) 3724 t = parent; 3725 else { 3726 t = parent.predicate("fhir:"+parentType+'.'+name); 3727 } 3728 composeBackboneElement(t, "messaging", name, element, index); 3729 for (int i = 0; i < element.getEndpoint().size(); i++) { 3730 composeCapabilityStatementMessagingEndpointComponent(t, "CapabilityStatementMessagingComponent", "endpoint", element.getEndpoint().get(i), i); 3731 } 3732 if (element.hasReliableCacheElement()) { 3733 composeUnsignedInt(t, "CapabilityStatementMessagingComponent", "reliableCache", element.getReliableCacheElement(), -1); 3734 } 3735 if (element.hasDocumentationElement()) { 3736 composeMarkdown(t, "CapabilityStatementMessagingComponent", "documentation", element.getDocumentationElement(), -1); 3737 } 3738 for (int i = 0; i < element.getSupportedMessage().size(); i++) { 3739 composeCapabilityStatementMessagingSupportedMessageComponent(t, "CapabilityStatementMessagingComponent", "supportedMessage", element.getSupportedMessage().get(i), i); 3740 } 3741 } 3742 3743 protected void composeCapabilityStatementMessagingEndpointComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEndpointComponent element, int index) { 3744 if (element == null) 3745 return; 3746 Complex t; 3747 if (Utilities.noString(parentType)) 3748 t = parent; 3749 else { 3750 t = parent.predicate("fhir:"+parentType+'.'+name); 3751 } 3752 composeBackboneElement(t, "endpoint", name, element, index); 3753 if (element.hasProtocol()) { 3754 composeCoding(t, "CapabilityStatementMessagingEndpointComponent", "protocol", element.getProtocol(), -1); 3755 } 3756 if (element.hasAddressElement()) { 3757 composeUrl(t, "CapabilityStatementMessagingEndpointComponent", "address", element.getAddressElement(), -1); 3758 } 3759 } 3760 3761 protected void composeCapabilityStatementMessagingSupportedMessageComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent element, int index) { 3762 if (element == null) 3763 return; 3764 Complex t; 3765 if (Utilities.noString(parentType)) 3766 t = parent; 3767 else { 3768 t = parent.predicate("fhir:"+parentType+'.'+name); 3769 } 3770 composeBackboneElement(t, "supportedMessage", name, element, index); 3771 if (element.hasModeElement()) { 3772 composeEnum(t, "CapabilityStatementMessagingSupportedMessageComponent", "mode", element.getModeElement(), -1); 3773 } 3774 if (element.hasDefinitionElement()) { 3775 composeCanonical(t, "CapabilityStatementMessagingSupportedMessageComponent", "definition", element.getDefinitionElement(), -1); 3776 } 3777 } 3778 3779 protected void composeCapabilityStatementDocumentComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementDocumentComponent element, int index) { 3780 if (element == null) 3781 return; 3782 Complex t; 3783 if (Utilities.noString(parentType)) 3784 t = parent; 3785 else { 3786 t = parent.predicate("fhir:"+parentType+'.'+name); 3787 } 3788 composeBackboneElement(t, "document", name, element, index); 3789 if (element.hasModeElement()) { 3790 composeEnum(t, "CapabilityStatementDocumentComponent", "mode", element.getModeElement(), -1); 3791 } 3792 if (element.hasDocumentationElement()) { 3793 composeMarkdown(t, "CapabilityStatementDocumentComponent", "documentation", element.getDocumentationElement(), -1); 3794 } 3795 if (element.hasProfileElement()) { 3796 composeCanonical(t, "CapabilityStatementDocumentComponent", "profile", element.getProfileElement(), -1); 3797 } 3798 } 3799 3800 protected void composeCapabilityStatement2(Complex parent, String parentType, String name, CapabilityStatement2 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 composeCanonicalResource(t, "CapabilityStatement2", name, element, index); 3810 if (element.hasUrlElement()) { 3811 composeUri(t, "CapabilityStatement2", "url", element.getUrlElement(), -1); 3812 } 3813 if (element.hasVersionElement()) { 3814 composeString(t, "CapabilityStatement2", "version", element.getVersionElement(), -1); 3815 } 3816 if (element.hasNameElement()) { 3817 composeString(t, "CapabilityStatement2", "name", element.getNameElement(), -1); 3818 } 3819 if (element.hasTitleElement()) { 3820 composeString(t, "CapabilityStatement2", "title", element.getTitleElement(), -1); 3821 } 3822 if (element.hasStatusElement()) { 3823 composeEnum(t, "CapabilityStatement2", "status", element.getStatusElement(), -1); 3824 } 3825 if (element.hasExperimentalElement()) { 3826 composeBoolean(t, "CapabilityStatement2", "experimental", element.getExperimentalElement(), -1); 3827 } 3828 if (element.hasDateElement()) { 3829 composeDateTime(t, "CapabilityStatement2", "date", element.getDateElement(), -1); 3830 } 3831 if (element.hasPublisherElement()) { 3832 composeString(t, "CapabilityStatement2", "publisher", element.getPublisherElement(), -1); 3833 } 3834 for (int i = 0; i < element.getContact().size(); i++) { 3835 composeContactDetail(t, "CapabilityStatement2", "contact", element.getContact().get(i), i); 3836 } 3837 if (element.hasDescriptionElement()) { 3838 composeMarkdown(t, "CapabilityStatement2", "description", element.getDescriptionElement(), -1); 3839 } 3840 for (int i = 0; i < element.getUseContext().size(); i++) { 3841 composeUsageContext(t, "CapabilityStatement2", "useContext", element.getUseContext().get(i), i); 3842 } 3843 for (int i = 0; i < element.getJurisdiction().size(); i++) { 3844 composeCodeableConcept(t, "CapabilityStatement2", "jurisdiction", element.getJurisdiction().get(i), i); 3845 } 3846 if (element.hasPurposeElement()) { 3847 composeMarkdown(t, "CapabilityStatement2", "purpose", element.getPurposeElement(), -1); 3848 } 3849 if (element.hasCopyrightElement()) { 3850 composeMarkdown(t, "CapabilityStatement2", "copyright", element.getCopyrightElement(), -1); 3851 } 3852 if (element.hasKindElement()) { 3853 composeEnum(t, "CapabilityStatement2", "kind", element.getKindElement(), -1); 3854 } 3855 for (int i = 0; i < element.getInstantiates().size(); i++) { 3856 composeCanonical(t, "CapabilityStatement2", "instantiates", element.getInstantiates().get(i), i); 3857 } 3858 for (int i = 0; i < element.getImports().size(); i++) { 3859 composeCanonical(t, "CapabilityStatement2", "imports", element.getImports().get(i), i); 3860 } 3861 if (element.hasSoftware()) { 3862 composeCapabilityStatement2SoftwareComponent(t, "CapabilityStatement2", "software", element.getSoftware(), -1); 3863 } 3864 if (element.hasImplementation()) { 3865 composeCapabilityStatement2ImplementationComponent(t, "CapabilityStatement2", "implementation", element.getImplementation(), -1); 3866 } 3867 if (element.hasFhirVersionElement()) { 3868 composeEnum(t, "CapabilityStatement2", "fhirVersion", element.getFhirVersionElement(), -1); 3869 } 3870 for (int i = 0; i < element.getFormat().size(); i++) { 3871 composeCode(t, "CapabilityStatement2", "format", element.getFormat().get(i), i); 3872 } 3873 for (int i = 0; i < element.getPatchFormat().size(); i++) { 3874 composeCode(t, "CapabilityStatement2", "patchFormat", element.getPatchFormat().get(i), i); 3875 } 3876 for (int i = 0; i < element.getImplementationGuide().size(); i++) { 3877 composeCanonical(t, "CapabilityStatement2", "implementationGuide", element.getImplementationGuide().get(i), i); 3878 } 3879 for (int i = 0; i < element.getRest().size(); i++) { 3880 composeCapabilityStatement2RestComponent(t, "CapabilityStatement2", "rest", element.getRest().get(i), i); 3881 } 3882 } 3883 3884 protected void composeCapabilityStatement2SoftwareComponent(Complex parent, String parentType, String name, CapabilityStatement2.CapabilityStatement2SoftwareComponent element, int index) { 3885 if (element == null) 3886 return; 3887 Complex t; 3888 if (Utilities.noString(parentType)) 3889 t = parent; 3890 else { 3891 t = parent.predicate("fhir:"+parentType+'.'+name); 3892 } 3893 composeBackboneElement(t, "software", name, element, index); 3894 if (element.hasNameElement()) { 3895 composeString(t, "CapabilityStatement2SoftwareComponent", "name", element.getNameElement(), -1); 3896 } 3897 if (element.hasVersionElement()) { 3898 composeString(t, "CapabilityStatement2SoftwareComponent", "version", element.getVersionElement(), -1); 3899 } 3900 if (element.hasReleaseDateElement()) { 3901 composeDateTime(t, "CapabilityStatement2SoftwareComponent", "releaseDate", element.getReleaseDateElement(), -1); 3902 } 3903 } 3904 3905 protected void composeCapabilityStatement2ImplementationComponent(Complex parent, String parentType, String name, CapabilityStatement2.CapabilityStatement2ImplementationComponent element, int index) { 3906 if (element == null) 3907 return; 3908 Complex t; 3909 if (Utilities.noString(parentType)) 3910 t = parent; 3911 else { 3912 t = parent.predicate("fhir:"+parentType+'.'+name); 3913 } 3914 composeBackboneElement(t, "implementation", name, element, index); 3915 if (element.hasDescriptionElement()) { 3916 composeString(t, "CapabilityStatement2ImplementationComponent", "description", element.getDescriptionElement(), -1); 3917 } 3918 if (element.hasUrlElement()) { 3919 composeUrl(t, "CapabilityStatement2ImplementationComponent", "url", element.getUrlElement(), -1); 3920 } 3921 if (element.hasCustodian()) { 3922 composeReference(t, "CapabilityStatement2ImplementationComponent", "custodian", element.getCustodian(), -1); 3923 } 3924 } 3925 3926 protected void composeCapabilityStatement2RestComponent(Complex parent, String parentType, String name, CapabilityStatement2.CapabilityStatement2RestComponent element, int index) { 3927 if (element == null) 3928 return; 3929 Complex t; 3930 if (Utilities.noString(parentType)) 3931 t = parent; 3932 else { 3933 t = parent.predicate("fhir:"+parentType+'.'+name); 3934 } 3935 composeBackboneElement(t, "rest", name, element, index); 3936 if (element.hasModeElement()) { 3937 composeEnum(t, "CapabilityStatement2RestComponent", "mode", element.getModeElement(), -1); 3938 } 3939 if (element.hasDocumentationElement()) { 3940 composeMarkdown(t, "CapabilityStatement2RestComponent", "documentation", element.getDocumentationElement(), -1); 3941 } 3942 for (int i = 0; i < element.getResource().size(); i++) { 3943 composeCapabilityStatement2RestResourceComponent(t, "CapabilityStatement2RestComponent", "resource", element.getResource().get(i), i); 3944 } 3945 for (int i = 0; i < element.getInteraction().size(); i++) { 3946 composeCapabilityStatement2SystemInteractionComponent(t, "CapabilityStatement2RestComponent", "interaction", element.getInteraction().get(i), i); 3947 } 3948 for (int i = 0; i < element.getSearchParam().size(); i++) { 3949 composeCapabilityStatement2RestResourceSearchParamComponent(t, "CapabilityStatement2RestComponent", "searchParam", element.getSearchParam().get(i), i); 3950 } 3951 for (int i = 0; i < element.getOperation().size(); i++) { 3952 composeCapabilityStatement2RestResourceOperationComponent(t, "CapabilityStatement2RestComponent", "operation", element.getOperation().get(i), i); 3953 } 3954 for (int i = 0; i < element.getCompartment().size(); i++) { 3955 composeCanonical(t, "CapabilityStatement2RestComponent", "compartment", element.getCompartment().get(i), i); 3956 } 3957 } 3958 3959 protected void composeCapabilityStatement2RestResourceComponent(Complex parent, String parentType, String name, CapabilityStatement2.CapabilityStatement2RestResourceComponent element, int index) { 3960 if (element == null) 3961 return; 3962 Complex t; 3963 if (Utilities.noString(parentType)) 3964 t = parent; 3965 else { 3966 t = parent.predicate("fhir:"+parentType+'.'+name); 3967 } 3968 composeBackboneElement(t, "resource", name, element, index); 3969 if (element.hasTypeElement()) { 3970 composeCode(t, "CapabilityStatement2RestResourceComponent", "type", element.getTypeElement(), -1); 3971 } 3972 if (element.hasProfileElement()) { 3973 composeCanonical(t, "CapabilityStatement2RestResourceComponent", "profile", element.getProfileElement(), -1); 3974 } 3975 for (int i = 0; i < element.getSupportedProfile().size(); i++) { 3976 composeCanonical(t, "CapabilityStatement2RestResourceComponent", "supportedProfile", element.getSupportedProfile().get(i), i); 3977 } 3978 if (element.hasDocumentationElement()) { 3979 composeMarkdown(t, "CapabilityStatement2RestResourceComponent", "documentation", element.getDocumentationElement(), -1); 3980 } 3981 for (int i = 0; i < element.getInteraction().size(); i++) { 3982 composeCapabilityStatement2ResourceInteractionComponent(t, "CapabilityStatement2RestResourceComponent", "interaction", element.getInteraction().get(i), i); 3983 } 3984 for (int i = 0; i < element.getSearchParam().size(); i++) { 3985 composeCapabilityStatement2RestResourceSearchParamComponent(t, "CapabilityStatement2RestResourceComponent", "searchParam", element.getSearchParam().get(i), i); 3986 } 3987 for (int i = 0; i < element.getOperation().size(); i++) { 3988 composeCapabilityStatement2RestResourceOperationComponent(t, "CapabilityStatement2RestResourceComponent", "operation", element.getOperation().get(i), i); 3989 } 3990 } 3991 3992 protected void composeCapabilityStatement2ResourceInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement2.ResourceInteractionComponent element, int index) { 3993 if (element == null) 3994 return; 3995 Complex t; 3996 if (Utilities.noString(parentType)) 3997 t = parent; 3998 else { 3999 t = parent.predicate("fhir:"+parentType+'.'+name); 4000 } 4001 composeBackboneElement(t, "interaction", name, element, index); 4002 if (element.hasCodeElement()) { 4003 composeEnum(t, "ResourceInteractionComponent", "code", element.getCodeElement(), -1); 4004 } 4005 if (element.hasDocumentationElement()) { 4006 composeMarkdown(t, "ResourceInteractionComponent", "documentation", element.getDocumentationElement(), -1); 4007 } 4008 } 4009 4010 protected void composeCapabilityStatement2RestResourceSearchParamComponent(Complex parent, String parentType, String name, CapabilityStatement2.CapabilityStatement2RestResourceSearchParamComponent element, int index) { 4011 if (element == null) 4012 return; 4013 Complex t; 4014 if (Utilities.noString(parentType)) 4015 t = parent; 4016 else { 4017 t = parent.predicate("fhir:"+parentType+'.'+name); 4018 } 4019 composeBackboneElement(t, "searchParam", name, element, index); 4020 if (element.hasNameElement()) { 4021 composeString(t, "CapabilityStatement2RestResourceSearchParamComponent", "name", element.getNameElement(), -1); 4022 } 4023 if (element.hasDefinitionElement()) { 4024 composeCanonical(t, "CapabilityStatement2RestResourceSearchParamComponent", "definition", element.getDefinitionElement(), -1); 4025 } 4026 if (element.hasTypeElement()) { 4027 composeEnum(t, "CapabilityStatement2RestResourceSearchParamComponent", "type", element.getTypeElement(), -1); 4028 } 4029 if (element.hasDocumentationElement()) { 4030 composeMarkdown(t, "CapabilityStatement2RestResourceSearchParamComponent", "documentation", element.getDocumentationElement(), -1); 4031 } 4032 } 4033 4034 protected void composeCapabilityStatement2RestResourceOperationComponent(Complex parent, String parentType, String name, CapabilityStatement2.CapabilityStatement2RestResourceOperationComponent element, int index) { 4035 if (element == null) 4036 return; 4037 Complex t; 4038 if (Utilities.noString(parentType)) 4039 t = parent; 4040 else { 4041 t = parent.predicate("fhir:"+parentType+'.'+name); 4042 } 4043 composeBackboneElement(t, "operation", name, element, index); 4044 if (element.hasNameElement()) { 4045 composeString(t, "CapabilityStatement2RestResourceOperationComponent", "name", element.getNameElement(), -1); 4046 } 4047 if (element.hasDefinitionElement()) { 4048 composeCanonical(t, "CapabilityStatement2RestResourceOperationComponent", "definition", element.getDefinitionElement(), -1); 4049 } 4050 if (element.hasDocumentationElement()) { 4051 composeMarkdown(t, "CapabilityStatement2RestResourceOperationComponent", "documentation", element.getDocumentationElement(), -1); 4052 } 4053 } 4054 4055 protected void composeCapabilityStatement2SystemInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement2.SystemInteractionComponent element, int index) { 4056 if (element == null) 4057 return; 4058 Complex t; 4059 if (Utilities.noString(parentType)) 4060 t = parent; 4061 else { 4062 t = parent.predicate("fhir:"+parentType+'.'+name); 4063 } 4064 composeBackboneElement(t, "interaction", name, element, index); 4065 if (element.hasCodeElement()) { 4066 composeEnum(t, "SystemInteractionComponent", "code", element.getCodeElement(), -1); 4067 } 4068 if (element.hasDocumentationElement()) { 4069 composeMarkdown(t, "SystemInteractionComponent", "documentation", element.getDocumentationElement(), -1); 4070 } 4071 } 4072 4073 protected void composeCarePlan(Complex parent, String parentType, String name, CarePlan element, int index) { 4074 if (element == null) 4075 return; 4076 Complex t; 4077 if (Utilities.noString(parentType)) 4078 t = parent; 4079 else { 4080 t = parent.predicate("fhir:"+parentType+'.'+name); 4081 } 4082 composeDomainResource(t, "CarePlan", name, element, index); 4083 for (int i = 0; i < element.getIdentifier().size(); i++) { 4084 composeIdentifier(t, "CarePlan", "identifier", element.getIdentifier().get(i), i); 4085 } 4086 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) { 4087 composeCanonical(t, "CarePlan", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 4088 } 4089 for (int i = 0; i < element.getInstantiatesUri().size(); i++) { 4090 composeUri(t, "CarePlan", "instantiatesUri", element.getInstantiatesUri().get(i), i); 4091 } 4092 for (int i = 0; i < element.getBasedOn().size(); i++) { 4093 composeReference(t, "CarePlan", "basedOn", element.getBasedOn().get(i), i); 4094 } 4095 for (int i = 0; i < element.getReplaces().size(); i++) { 4096 composeReference(t, "CarePlan", "replaces", element.getReplaces().get(i), i); 4097 } 4098 for (int i = 0; i < element.getPartOf().size(); i++) { 4099 composeReference(t, "CarePlan", "partOf", element.getPartOf().get(i), i); 4100 } 4101 if (element.hasStatusElement()) { 4102 composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1); 4103 } 4104 if (element.hasIntentElement()) { 4105 composeEnum(t, "CarePlan", "intent", element.getIntentElement(), -1); 4106 } 4107 for (int i = 0; i < element.getCategory().size(); i++) { 4108 composeCodeableConcept(t, "CarePlan", "category", element.getCategory().get(i), i); 4109 } 4110 if (element.hasTitleElement()) { 4111 composeString(t, "CarePlan", "title", element.getTitleElement(), -1); 4112 } 4113 if (element.hasDescriptionElement()) { 4114 composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1); 4115 } 4116 if (element.hasSubject()) { 4117 composeReference(t, "CarePlan", "subject", element.getSubject(), -1); 4118 } 4119 if (element.hasEncounter()) { 4120 composeReference(t, "CarePlan", "encounter", element.getEncounter(), -1); 4121 } 4122 if (element.hasPeriod()) { 4123 composePeriod(t, "CarePlan", "period", element.getPeriod(), -1); 4124 } 4125 if (element.hasCreatedElement()) { 4126 composeDateTime(t, "CarePlan", "created", element.getCreatedElement(), -1); 4127 } 4128 if (element.hasAuthor()) { 4129 composeReference(t, "CarePlan", "author", element.getAuthor(), -1); 4130 } 4131 for (int i = 0; i < element.getContributor().size(); i++) { 4132 composeReference(t, "CarePlan", "contributor", element.getContributor().get(i), i); 4133 } 4134 for (int i = 0; i < element.getCareTeam().size(); i++) { 4135 composeReference(t, "CarePlan", "careTeam", element.getCareTeam().get(i), i); 4136 } 4137 for (int i = 0; i < element.getAddresses().size(); i++) { 4138 composeCodeableReference(t, "CarePlan", "addresses", element.getAddresses().get(i), i); 4139 } 4140 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 4141 composeReference(t, "CarePlan", "supportingInfo", element.getSupportingInfo().get(i), i); 4142 } 4143 for (int i = 0; i < element.getGoal().size(); i++) { 4144 composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i); 4145 } 4146 for (int i = 0; i < element.getActivity().size(); i++) { 4147 composeCarePlanActivityComponent(t, "CarePlan", "activity", element.getActivity().get(i), i); 4148 } 4149 for (int i = 0; i < element.getNote().size(); i++) { 4150 composeAnnotation(t, "CarePlan", "note", element.getNote().get(i), i); 4151 } 4152 } 4153 4154 protected void composeCarePlanActivityComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityComponent element, int index) { 4155 if (element == null) 4156 return; 4157 Complex t; 4158 if (Utilities.noString(parentType)) 4159 t = parent; 4160 else { 4161 t = parent.predicate("fhir:"+parentType+'.'+name); 4162 } 4163 composeBackboneElement(t, "activity", name, element, index); 4164 for (int i = 0; i < element.getOutcome().size(); i++) { 4165 composeCodeableReference(t, "CarePlanActivityComponent", "outcome", element.getOutcome().get(i), i); 4166 } 4167 for (int i = 0; i < element.getProgress().size(); i++) { 4168 composeAnnotation(t, "CarePlanActivityComponent", "progress", element.getProgress().get(i), i); 4169 } 4170 if (element.hasReference()) { 4171 composeReference(t, "CarePlanActivityComponent", "reference", element.getReference(), -1); 4172 } 4173 if (element.hasDetail()) { 4174 composeCarePlanActivityDetailComponent(t, "CarePlanActivityComponent", "detail", element.getDetail(), -1); 4175 } 4176 } 4177 4178 protected void composeCarePlanActivityDetailComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityDetailComponent element, int index) { 4179 if (element == null) 4180 return; 4181 Complex t; 4182 if (Utilities.noString(parentType)) 4183 t = parent; 4184 else { 4185 t = parent.predicate("fhir:"+parentType+'.'+name); 4186 } 4187 composeBackboneElement(t, "detail", name, element, index); 4188 if (element.hasKindElement()) { 4189 composeEnum(t, "CarePlanActivityDetailComponent", "kind", element.getKindElement(), -1); 4190 } 4191 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) { 4192 composeCanonical(t, "CarePlanActivityDetailComponent", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 4193 } 4194 for (int i = 0; i < element.getInstantiatesUri().size(); i++) { 4195 composeUri(t, "CarePlanActivityDetailComponent", "instantiatesUri", element.getInstantiatesUri().get(i), i); 4196 } 4197 if (element.hasCode()) { 4198 composeCodeableConcept(t, "CarePlanActivityDetailComponent", "code", element.getCode(), -1); 4199 } 4200 for (int i = 0; i < element.getReason().size(); i++) { 4201 composeCodeableReference(t, "CarePlanActivityDetailComponent", "reason", element.getReason().get(i), i); 4202 } 4203 for (int i = 0; i < element.getGoal().size(); i++) { 4204 composeReference(t, "CarePlanActivityDetailComponent", "goal", element.getGoal().get(i), i); 4205 } 4206 if (element.hasStatusElement()) { 4207 composeEnum(t, "CarePlanActivityDetailComponent", "status", element.getStatusElement(), -1); 4208 } 4209 if (element.hasStatusReason()) { 4210 composeCodeableConcept(t, "CarePlanActivityDetailComponent", "statusReason", element.getStatusReason(), -1); 4211 } 4212 if (element.hasDoNotPerformElement()) { 4213 composeBoolean(t, "CarePlanActivityDetailComponent", "doNotPerform", element.getDoNotPerformElement(), -1); 4214 } 4215 if (element.hasScheduled()) { 4216 composeType(t, "CarePlanActivityDetailComponent", "scheduled", element.getScheduled(), -1); 4217 } 4218 if (element.hasLocation()) { 4219 composeReference(t, "CarePlanActivityDetailComponent", "location", element.getLocation(), -1); 4220 } 4221 if (element.hasReported()) { 4222 composeType(t, "CarePlanActivityDetailComponent", "reported", element.getReported(), -1); 4223 } 4224 for (int i = 0; i < element.getPerformer().size(); i++) { 4225 composeReference(t, "CarePlanActivityDetailComponent", "performer", element.getPerformer().get(i), i); 4226 } 4227 if (element.hasProduct()) { 4228 composeType(t, "CarePlanActivityDetailComponent", "product", element.getProduct(), -1); 4229 } 4230 if (element.hasDailyAmount()) { 4231 composeQuantity(t, "CarePlanActivityDetailComponent", "dailyAmount", element.getDailyAmount(), -1); 4232 } 4233 if (element.hasQuantity()) { 4234 composeQuantity(t, "CarePlanActivityDetailComponent", "quantity", element.getQuantity(), -1); 4235 } 4236 if (element.hasDescriptionElement()) { 4237 composeString(t, "CarePlanActivityDetailComponent", "description", element.getDescriptionElement(), -1); 4238 } 4239 } 4240 4241 protected void composeCareTeam(Complex parent, String parentType, String name, CareTeam element, int index) { 4242 if (element == null) 4243 return; 4244 Complex t; 4245 if (Utilities.noString(parentType)) 4246 t = parent; 4247 else { 4248 t = parent.predicate("fhir:"+parentType+'.'+name); 4249 } 4250 composeDomainResource(t, "CareTeam", name, element, index); 4251 for (int i = 0; i < element.getIdentifier().size(); i++) { 4252 composeIdentifier(t, "CareTeam", "identifier", element.getIdentifier().get(i), i); 4253 } 4254 if (element.hasStatusElement()) { 4255 composeEnum(t, "CareTeam", "status", element.getStatusElement(), -1); 4256 } 4257 for (int i = 0; i < element.getCategory().size(); i++) { 4258 composeCodeableConcept(t, "CareTeam", "category", element.getCategory().get(i), i); 4259 } 4260 if (element.hasNameElement()) { 4261 composeString(t, "CareTeam", "name", element.getNameElement(), -1); 4262 } 4263 if (element.hasSubject()) { 4264 composeReference(t, "CareTeam", "subject", element.getSubject(), -1); 4265 } 4266 if (element.hasPeriod()) { 4267 composePeriod(t, "CareTeam", "period", element.getPeriod(), -1); 4268 } 4269 for (int i = 0; i < element.getParticipant().size(); i++) { 4270 composeCareTeamParticipantComponent(t, "CareTeam", "participant", element.getParticipant().get(i), i); 4271 } 4272 for (int i = 0; i < element.getReason().size(); i++) { 4273 composeCodeableReference(t, "CareTeam", "reason", element.getReason().get(i), i); 4274 } 4275 for (int i = 0; i < element.getManagingOrganization().size(); i++) { 4276 composeReference(t, "CareTeam", "managingOrganization", element.getManagingOrganization().get(i), i); 4277 } 4278 for (int i = 0; i < element.getTelecom().size(); i++) { 4279 composeContactPoint(t, "CareTeam", "telecom", element.getTelecom().get(i), i); 4280 } 4281 for (int i = 0; i < element.getNote().size(); i++) { 4282 composeAnnotation(t, "CareTeam", "note", element.getNote().get(i), i); 4283 } 4284 } 4285 4286 protected void composeCareTeamParticipantComponent(Complex parent, String parentType, String name, CareTeam.CareTeamParticipantComponent element, int index) { 4287 if (element == null) 4288 return; 4289 Complex t; 4290 if (Utilities.noString(parentType)) 4291 t = parent; 4292 else { 4293 t = parent.predicate("fhir:"+parentType+'.'+name); 4294 } 4295 composeBackboneElement(t, "participant", name, element, index); 4296 if (element.hasRole()) { 4297 composeCodeableConcept(t, "CareTeamParticipantComponent", "role", element.getRole(), -1); 4298 } 4299 if (element.hasMember()) { 4300 composeReference(t, "CareTeamParticipantComponent", "member", element.getMember(), -1); 4301 } 4302 if (element.hasOnBehalfOf()) { 4303 composeReference(t, "CareTeamParticipantComponent", "onBehalfOf", element.getOnBehalfOf(), -1); 4304 } 4305 if (element.hasCoverage()) { 4306 composeType(t, "CareTeamParticipantComponent", "coverage", element.getCoverage(), -1); 4307 } 4308 } 4309 4310 protected void composeCatalogEntry(Complex parent, String parentType, String name, CatalogEntry 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, "CatalogEntry", name, element, index); 4320 for (int i = 0; i < element.getIdentifier().size(); i++) { 4321 composeIdentifier(t, "CatalogEntry", "identifier", element.getIdentifier().get(i), i); 4322 } 4323 if (element.hasNameElement()) { 4324 composeString(t, "CatalogEntry", "name", element.getNameElement(), -1); 4325 } 4326 if (element.hasTypeElement()) { 4327 composeEnum(t, "CatalogEntry", "type", element.getTypeElement(), -1); 4328 } 4329 if (element.hasStatusElement()) { 4330 composeEnum(t, "CatalogEntry", "status", element.getStatusElement(), -1); 4331 } 4332 if (element.hasEffectivePeriod()) { 4333 composePeriod(t, "CatalogEntry", "effectivePeriod", element.getEffectivePeriod(), -1); 4334 } 4335 if (element.hasOrderableElement()) { 4336 composeBoolean(t, "CatalogEntry", "orderable", element.getOrderableElement(), -1); 4337 } 4338 if (element.hasReferencedItem()) { 4339 composeReference(t, "CatalogEntry", "referencedItem", element.getReferencedItem(), -1); 4340 } 4341 for (int i = 0; i < element.getRelatedEntry().size(); i++) { 4342 composeCatalogEntryRelatedEntryComponent(t, "CatalogEntry", "relatedEntry", element.getRelatedEntry().get(i), i); 4343 } 4344 if (element.hasUpdatedBy()) { 4345 composeReference(t, "CatalogEntry", "updatedBy", element.getUpdatedBy(), -1); 4346 } 4347 for (int i = 0; i < element.getNote().size(); i++) { 4348 composeAnnotation(t, "CatalogEntry", "note", element.getNote().get(i), i); 4349 } 4350 if (element.hasEstimatedDuration()) { 4351 composeDuration(t, "CatalogEntry", "estimatedDuration", element.getEstimatedDuration(), -1); 4352 } 4353 for (int i = 0; i < element.getBillingCode().size(); i++) { 4354 composeCodeableConcept(t, "CatalogEntry", "billingCode", element.getBillingCode().get(i), i); 4355 } 4356 if (element.hasBillingSummaryElement()) { 4357 composeString(t, "CatalogEntry", "billingSummary", element.getBillingSummaryElement(), -1); 4358 } 4359 if (element.hasScheduleSummaryElement()) { 4360 composeString(t, "CatalogEntry", "scheduleSummary", element.getScheduleSummaryElement(), -1); 4361 } 4362 if (element.hasLimitationSummaryElement()) { 4363 composeString(t, "CatalogEntry", "limitationSummary", element.getLimitationSummaryElement(), -1); 4364 } 4365 if (element.hasRegulatorySummaryElement()) { 4366 composeString(t, "CatalogEntry", "regulatorySummary", element.getRegulatorySummaryElement(), -1); 4367 } 4368 } 4369 4370 protected void composeCatalogEntryRelatedEntryComponent(Complex parent, String parentType, String name, CatalogEntry.CatalogEntryRelatedEntryComponent 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, "relatedEntry", name, element, index); 4380 if (element.hasRelationshipElement()) { 4381 composeEnum(t, "CatalogEntryRelatedEntryComponent", "relationship", element.getRelationshipElement(), -1); 4382 } 4383 if (element.hasTarget()) { 4384 composeReference(t, "CatalogEntryRelatedEntryComponent", "target", element.getTarget(), -1); 4385 } 4386 } 4387 4388 protected void composeChargeItem(Complex parent, String parentType, String name, ChargeItem element, int index) { 4389 if (element == null) 4390 return; 4391 Complex t; 4392 if (Utilities.noString(parentType)) 4393 t = parent; 4394 else { 4395 t = parent.predicate("fhir:"+parentType+'.'+name); 4396 } 4397 composeDomainResource(t, "ChargeItem", name, element, index); 4398 for (int i = 0; i < element.getIdentifier().size(); i++) { 4399 composeIdentifier(t, "ChargeItem", "identifier", element.getIdentifier().get(i), i); 4400 } 4401 for (int i = 0; i < element.getDefinitionUri().size(); i++) { 4402 composeUri(t, "ChargeItem", "definitionUri", element.getDefinitionUri().get(i), i); 4403 } 4404 for (int i = 0; i < element.getDefinitionCanonical().size(); i++) { 4405 composeCanonical(t, "ChargeItem", "definitionCanonical", element.getDefinitionCanonical().get(i), i); 4406 } 4407 if (element.hasStatusElement()) { 4408 composeEnum(t, "ChargeItem", "status", element.getStatusElement(), -1); 4409 } 4410 for (int i = 0; i < element.getPartOf().size(); i++) { 4411 composeReference(t, "ChargeItem", "partOf", element.getPartOf().get(i), i); 4412 } 4413 if (element.hasCode()) { 4414 composeCodeableConcept(t, "ChargeItem", "code", element.getCode(), -1); 4415 } 4416 if (element.hasSubject()) { 4417 composeReference(t, "ChargeItem", "subject", element.getSubject(), -1); 4418 } 4419 if (element.hasContext()) { 4420 composeReference(t, "ChargeItem", "context", element.getContext(), -1); 4421 } 4422 if (element.hasOccurrence()) { 4423 composeType(t, "ChargeItem", "occurrence", element.getOccurrence(), -1); 4424 } 4425 for (int i = 0; i < element.getPerformer().size(); i++) { 4426 composeChargeItemPerformerComponent(t, "ChargeItem", "performer", element.getPerformer().get(i), i); 4427 } 4428 if (element.hasPerformingOrganization()) { 4429 composeReference(t, "ChargeItem", "performingOrganization", element.getPerformingOrganization(), -1); 4430 } 4431 if (element.hasRequestingOrganization()) { 4432 composeReference(t, "ChargeItem", "requestingOrganization", element.getRequestingOrganization(), -1); 4433 } 4434 if (element.hasCostCenter()) { 4435 composeReference(t, "ChargeItem", "costCenter", element.getCostCenter(), -1); 4436 } 4437 if (element.hasQuantity()) { 4438 composeQuantity(t, "ChargeItem", "quantity", element.getQuantity(), -1); 4439 } 4440 for (int i = 0; i < element.getBodysite().size(); i++) { 4441 composeCodeableConcept(t, "ChargeItem", "bodysite", element.getBodysite().get(i), i); 4442 } 4443 if (element.hasFactorOverrideElement()) { 4444 composeDecimal(t, "ChargeItem", "factorOverride", element.getFactorOverrideElement(), -1); 4445 } 4446 if (element.hasPriceOverride()) { 4447 composeMoney(t, "ChargeItem", "priceOverride", element.getPriceOverride(), -1); 4448 } 4449 if (element.hasOverrideReasonElement()) { 4450 composeString(t, "ChargeItem", "overrideReason", element.getOverrideReasonElement(), -1); 4451 } 4452 if (element.hasEnterer()) { 4453 composeReference(t, "ChargeItem", "enterer", element.getEnterer(), -1); 4454 } 4455 if (element.hasEnteredDateElement()) { 4456 composeDateTime(t, "ChargeItem", "enteredDate", element.getEnteredDateElement(), -1); 4457 } 4458 for (int i = 0; i < element.getReason().size(); i++) { 4459 composeCodeableConcept(t, "ChargeItem", "reason", element.getReason().get(i), i); 4460 } 4461 for (int i = 0; i < element.getService().size(); i++) { 4462 composeReference(t, "ChargeItem", "service", element.getService().get(i), i); 4463 } 4464 if (element.hasProduct()) { 4465 composeType(t, "ChargeItem", "product", element.getProduct(), -1); 4466 } 4467 for (int i = 0; i < element.getAccount().size(); i++) { 4468 composeReference(t, "ChargeItem", "account", element.getAccount().get(i), i); 4469 } 4470 for (int i = 0; i < element.getNote().size(); i++) { 4471 composeAnnotation(t, "ChargeItem", "note", element.getNote().get(i), i); 4472 } 4473 for (int i = 0; i < element.getSupportingInformation().size(); i++) { 4474 composeReference(t, "ChargeItem", "supportingInformation", element.getSupportingInformation().get(i), i); 4475 } 4476 } 4477 4478 protected void composeChargeItemPerformerComponent(Complex parent, String parentType, String name, ChargeItem.ChargeItemPerformerComponent element, int index) { 4479 if (element == null) 4480 return; 4481 Complex t; 4482 if (Utilities.noString(parentType)) 4483 t = parent; 4484 else { 4485 t = parent.predicate("fhir:"+parentType+'.'+name); 4486 } 4487 composeBackboneElement(t, "performer", name, element, index); 4488 if (element.hasFunction()) { 4489 composeCodeableConcept(t, "ChargeItemPerformerComponent", "function", element.getFunction(), -1); 4490 } 4491 if (element.hasActor()) { 4492 composeReference(t, "ChargeItemPerformerComponent", "actor", element.getActor(), -1); 4493 } 4494 } 4495 4496 protected void composeChargeItemDefinition(Complex parent, String parentType, String name, ChargeItemDefinition element, int index) { 4497 if (element == null) 4498 return; 4499 Complex t; 4500 if (Utilities.noString(parentType)) 4501 t = parent; 4502 else { 4503 t = parent.predicate("fhir:"+parentType+'.'+name); 4504 } 4505 composeMetadataResource(t, "ChargeItemDefinition", name, element, index); 4506 if (element.hasUrlElement()) { 4507 composeUri(t, "ChargeItemDefinition", "url", element.getUrlElement(), -1); 4508 } 4509 for (int i = 0; i < element.getIdentifier().size(); i++) { 4510 composeIdentifier(t, "ChargeItemDefinition", "identifier", element.getIdentifier().get(i), i); 4511 } 4512 if (element.hasVersionElement()) { 4513 composeString(t, "ChargeItemDefinition", "version", element.getVersionElement(), -1); 4514 } 4515 if (element.hasTitleElement()) { 4516 composeString(t, "ChargeItemDefinition", "title", element.getTitleElement(), -1); 4517 } 4518 for (int i = 0; i < element.getDerivedFromUri().size(); i++) { 4519 composeUri(t, "ChargeItemDefinition", "derivedFromUri", element.getDerivedFromUri().get(i), i); 4520 } 4521 for (int i = 0; i < element.getPartOf().size(); i++) { 4522 composeCanonical(t, "ChargeItemDefinition", "partOf", element.getPartOf().get(i), i); 4523 } 4524 for (int i = 0; i < element.getReplaces().size(); i++) { 4525 composeCanonical(t, "ChargeItemDefinition", "replaces", element.getReplaces().get(i), i); 4526 } 4527 if (element.hasStatusElement()) { 4528 composeEnum(t, "ChargeItemDefinition", "status", element.getStatusElement(), -1); 4529 } 4530 if (element.hasExperimentalElement()) { 4531 composeBoolean(t, "ChargeItemDefinition", "experimental", element.getExperimentalElement(), -1); 4532 } 4533 if (element.hasDateElement()) { 4534 composeDateTime(t, "ChargeItemDefinition", "date", element.getDateElement(), -1); 4535 } 4536 if (element.hasPublisherElement()) { 4537 composeString(t, "ChargeItemDefinition", "publisher", element.getPublisherElement(), -1); 4538 } 4539 for (int i = 0; i < element.getContact().size(); i++) { 4540 composeContactDetail(t, "ChargeItemDefinition", "contact", element.getContact().get(i), i); 4541 } 4542 if (element.hasDescriptionElement()) { 4543 composeMarkdown(t, "ChargeItemDefinition", "description", element.getDescriptionElement(), -1); 4544 } 4545 for (int i = 0; i < element.getUseContext().size(); i++) { 4546 composeUsageContext(t, "ChargeItemDefinition", "useContext", element.getUseContext().get(i), i); 4547 } 4548 for (int i = 0; i < element.getJurisdiction().size(); i++) { 4549 composeCodeableConcept(t, "ChargeItemDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 4550 } 4551 if (element.hasCopyrightElement()) { 4552 composeMarkdown(t, "ChargeItemDefinition", "copyright", element.getCopyrightElement(), -1); 4553 } 4554 if (element.hasApprovalDateElement()) { 4555 composeDate(t, "ChargeItemDefinition", "approvalDate", element.getApprovalDateElement(), -1); 4556 } 4557 if (element.hasLastReviewDateElement()) { 4558 composeDate(t, "ChargeItemDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 4559 } 4560 if (element.hasEffectivePeriod()) { 4561 composePeriod(t, "ChargeItemDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 4562 } 4563 if (element.hasCode()) { 4564 composeCodeableConcept(t, "ChargeItemDefinition", "code", element.getCode(), -1); 4565 } 4566 for (int i = 0; i < element.getInstance().size(); i++) { 4567 composeReference(t, "ChargeItemDefinition", "instance", element.getInstance().get(i), i); 4568 } 4569 for (int i = 0; i < element.getApplicability().size(); i++) { 4570 composeChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinition", "applicability", element.getApplicability().get(i), i); 4571 } 4572 for (int i = 0; i < element.getPropertyGroup().size(); i++) { 4573 composeChargeItemDefinitionPropertyGroupComponent(t, "ChargeItemDefinition", "propertyGroup", element.getPropertyGroup().get(i), i); 4574 } 4575 } 4576 4577 protected void composeChargeItemDefinitionApplicabilityComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionApplicabilityComponent element, int index) { 4578 if (element == null) 4579 return; 4580 Complex t; 4581 if (Utilities.noString(parentType)) 4582 t = parent; 4583 else { 4584 t = parent.predicate("fhir:"+parentType+'.'+name); 4585 } 4586 composeBackboneElement(t, "applicability", name, element, index); 4587 if (element.hasDescriptionElement()) { 4588 composeString(t, "ChargeItemDefinitionApplicabilityComponent", "description", element.getDescriptionElement(), -1); 4589 } 4590 if (element.hasLanguageElement()) { 4591 composeString(t, "ChargeItemDefinitionApplicabilityComponent", "language", element.getLanguageElement(), -1); 4592 } 4593 if (element.hasExpressionElement()) { 4594 composeString(t, "ChargeItemDefinitionApplicabilityComponent", "expression", element.getExpressionElement(), -1); 4595 } 4596 } 4597 4598 protected void composeChargeItemDefinitionPropertyGroupComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionPropertyGroupComponent element, int index) { 4599 if (element == null) 4600 return; 4601 Complex t; 4602 if (Utilities.noString(parentType)) 4603 t = parent; 4604 else { 4605 t = parent.predicate("fhir:"+parentType+'.'+name); 4606 } 4607 composeBackboneElement(t, "propertyGroup", name, element, index); 4608 for (int i = 0; i < element.getApplicability().size(); i++) { 4609 composeChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinitionPropertyGroupComponent", "applicability", element.getApplicability().get(i), i); 4610 } 4611 for (int i = 0; i < element.getPriceComponent().size(); i++) { 4612 composeChargeItemDefinitionPropertyGroupPriceComponentComponent(t, "ChargeItemDefinitionPropertyGroupComponent", "priceComponent", element.getPriceComponent().get(i), i); 4613 } 4614 } 4615 4616 protected void composeChargeItemDefinitionPropertyGroupPriceComponentComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionPropertyGroupPriceComponentComponent element, int index) { 4617 if (element == null) 4618 return; 4619 Complex t; 4620 if (Utilities.noString(parentType)) 4621 t = parent; 4622 else { 4623 t = parent.predicate("fhir:"+parentType+'.'+name); 4624 } 4625 composeBackboneElement(t, "priceComponent", name, element, index); 4626 if (element.hasTypeElement()) { 4627 composeEnum(t, "ChargeItemDefinitionPropertyGroupPriceComponentComponent", "type", element.getTypeElement(), -1); 4628 } 4629 if (element.hasCode()) { 4630 composeCodeableConcept(t, "ChargeItemDefinitionPropertyGroupPriceComponentComponent", "code", element.getCode(), -1); 4631 } 4632 if (element.hasFactorElement()) { 4633 composeDecimal(t, "ChargeItemDefinitionPropertyGroupPriceComponentComponent", "factor", element.getFactorElement(), -1); 4634 } 4635 if (element.hasAmount()) { 4636 composeMoney(t, "ChargeItemDefinitionPropertyGroupPriceComponentComponent", "amount", element.getAmount(), -1); 4637 } 4638 } 4639 4640 protected void composeClaim(Complex parent, String parentType, String name, Claim element, int index) { 4641 if (element == null) 4642 return; 4643 Complex t; 4644 if (Utilities.noString(parentType)) 4645 t = parent; 4646 else { 4647 t = parent.predicate("fhir:"+parentType+'.'+name); 4648 } 4649 composeDomainResource(t, "Claim", name, element, index); 4650 for (int i = 0; i < element.getIdentifier().size(); i++) { 4651 composeIdentifier(t, "Claim", "identifier", element.getIdentifier().get(i), i); 4652 } 4653 if (element.hasStatusElement()) { 4654 composeEnum(t, "Claim", "status", element.getStatusElement(), -1); 4655 } 4656 if (element.hasType()) { 4657 composeCodeableConcept(t, "Claim", "type", element.getType(), -1); 4658 } 4659 if (element.hasSubType()) { 4660 composeCodeableConcept(t, "Claim", "subType", element.getSubType(), -1); 4661 } 4662 if (element.hasUseElement()) { 4663 composeEnum(t, "Claim", "use", element.getUseElement(), -1); 4664 } 4665 if (element.hasPatient()) { 4666 composeReference(t, "Claim", "patient", element.getPatient(), -1); 4667 } 4668 if (element.hasBillablePeriod()) { 4669 composePeriod(t, "Claim", "billablePeriod", element.getBillablePeriod(), -1); 4670 } 4671 if (element.hasCreatedElement()) { 4672 composeDateTime(t, "Claim", "created", element.getCreatedElement(), -1); 4673 } 4674 if (element.hasEnterer()) { 4675 composeReference(t, "Claim", "enterer", element.getEnterer(), -1); 4676 } 4677 if (element.hasInsurer()) { 4678 composeReference(t, "Claim", "insurer", element.getInsurer(), -1); 4679 } 4680 if (element.hasProvider()) { 4681 composeReference(t, "Claim", "provider", element.getProvider(), -1); 4682 } 4683 if (element.hasPriority()) { 4684 composeCodeableConcept(t, "Claim", "priority", element.getPriority(), -1); 4685 } 4686 if (element.hasFundsReserve()) { 4687 composeCodeableConcept(t, "Claim", "fundsReserve", element.getFundsReserve(), -1); 4688 } 4689 for (int i = 0; i < element.getRelated().size(); i++) { 4690 composeClaimRelatedClaimComponent(t, "Claim", "related", element.getRelated().get(i), i); 4691 } 4692 if (element.hasPrescription()) { 4693 composeReference(t, "Claim", "prescription", element.getPrescription(), -1); 4694 } 4695 if (element.hasOriginalPrescription()) { 4696 composeReference(t, "Claim", "originalPrescription", element.getOriginalPrescription(), -1); 4697 } 4698 if (element.hasPayee()) { 4699 composeClaimPayeeComponent(t, "Claim", "payee", element.getPayee(), -1); 4700 } 4701 if (element.hasReferral()) { 4702 composeReference(t, "Claim", "referral", element.getReferral(), -1); 4703 } 4704 if (element.hasFacility()) { 4705 composeReference(t, "Claim", "facility", element.getFacility(), -1); 4706 } 4707 for (int i = 0; i < element.getCareTeam().size(); i++) { 4708 composeClaimCareTeamComponent(t, "Claim", "careTeam", element.getCareTeam().get(i), i); 4709 } 4710 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 4711 composeClaimSupportingInformationComponent(t, "Claim", "supportingInfo", element.getSupportingInfo().get(i), i); 4712 } 4713 for (int i = 0; i < element.getDiagnosis().size(); i++) { 4714 composeClaimDiagnosisComponent(t, "Claim", "diagnosis", element.getDiagnosis().get(i), i); 4715 } 4716 for (int i = 0; i < element.getProcedure().size(); i++) { 4717 composeClaimProcedureComponent(t, "Claim", "procedure", element.getProcedure().get(i), i); 4718 } 4719 for (int i = 0; i < element.getInsurance().size(); i++) { 4720 composeClaimInsuranceComponent(t, "Claim", "insurance", element.getInsurance().get(i), i); 4721 } 4722 if (element.hasAccident()) { 4723 composeClaimAccidentComponent(t, "Claim", "accident", element.getAccident(), -1); 4724 } 4725 for (int i = 0; i < element.getItem().size(); i++) { 4726 composeClaimItemComponent(t, "Claim", "item", element.getItem().get(i), i); 4727 } 4728 if (element.hasTotal()) { 4729 composeMoney(t, "Claim", "total", element.getTotal(), -1); 4730 } 4731 } 4732 4733 protected void composeClaimRelatedClaimComponent(Complex parent, String parentType, String name, Claim.RelatedClaimComponent element, int index) { 4734 if (element == null) 4735 return; 4736 Complex t; 4737 if (Utilities.noString(parentType)) 4738 t = parent; 4739 else { 4740 t = parent.predicate("fhir:"+parentType+'.'+name); 4741 } 4742 composeBackboneElement(t, "related", name, element, index); 4743 if (element.hasClaim()) { 4744 composeReference(t, "RelatedClaimComponent", "claim", element.getClaim(), -1); 4745 } 4746 if (element.hasRelationship()) { 4747 composeCodeableConcept(t, "RelatedClaimComponent", "relationship", element.getRelationship(), -1); 4748 } 4749 if (element.hasReference()) { 4750 composeIdentifier(t, "RelatedClaimComponent", "reference", element.getReference(), -1); 4751 } 4752 } 4753 4754 protected void composeClaimPayeeComponent(Complex parent, String parentType, String name, Claim.PayeeComponent element, int index) { 4755 if (element == null) 4756 return; 4757 Complex t; 4758 if (Utilities.noString(parentType)) 4759 t = parent; 4760 else { 4761 t = parent.predicate("fhir:"+parentType+'.'+name); 4762 } 4763 composeBackboneElement(t, "payee", name, element, index); 4764 if (element.hasType()) { 4765 composeCodeableConcept(t, "PayeeComponent", "type", element.getType(), -1); 4766 } 4767 if (element.hasParty()) { 4768 composeReference(t, "PayeeComponent", "party", element.getParty(), -1); 4769 } 4770 } 4771 4772 protected void composeClaimCareTeamComponent(Complex parent, String parentType, String name, Claim.CareTeamComponent element, int index) { 4773 if (element == null) 4774 return; 4775 Complex t; 4776 if (Utilities.noString(parentType)) 4777 t = parent; 4778 else { 4779 t = parent.predicate("fhir:"+parentType+'.'+name); 4780 } 4781 composeBackboneElement(t, "careTeam", name, element, index); 4782 if (element.hasSequenceElement()) { 4783 composePositiveInt(t, "CareTeamComponent", "sequence", element.getSequenceElement(), -1); 4784 } 4785 if (element.hasProvider()) { 4786 composeReference(t, "CareTeamComponent", "provider", element.getProvider(), -1); 4787 } 4788 if (element.hasResponsibleElement()) { 4789 composeBoolean(t, "CareTeamComponent", "responsible", element.getResponsibleElement(), -1); 4790 } 4791 if (element.hasRole()) { 4792 composeCodeableConcept(t, "CareTeamComponent", "role", element.getRole(), -1); 4793 } 4794 if (element.hasQualification()) { 4795 composeCodeableConcept(t, "CareTeamComponent", "qualification", element.getQualification(), -1); 4796 } 4797 } 4798 4799 protected void composeClaimSupportingInformationComponent(Complex parent, String parentType, String name, Claim.SupportingInformationComponent element, int index) { 4800 if (element == null) 4801 return; 4802 Complex t; 4803 if (Utilities.noString(parentType)) 4804 t = parent; 4805 else { 4806 t = parent.predicate("fhir:"+parentType+'.'+name); 4807 } 4808 composeBackboneElement(t, "supportingInfo", name, element, index); 4809 if (element.hasSequenceElement()) { 4810 composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1); 4811 } 4812 if (element.hasCategory()) { 4813 composeCodeableConcept(t, "SupportingInformationComponent", "category", element.getCategory(), -1); 4814 } 4815 if (element.hasCode()) { 4816 composeCodeableConcept(t, "SupportingInformationComponent", "code", element.getCode(), -1); 4817 } 4818 if (element.hasTiming()) { 4819 composeType(t, "SupportingInformationComponent", "timing", element.getTiming(), -1); 4820 } 4821 if (element.hasValue()) { 4822 composeType(t, "SupportingInformationComponent", "value", element.getValue(), -1); 4823 } 4824 if (element.hasReason()) { 4825 composeCodeableConcept(t, "SupportingInformationComponent", "reason", element.getReason(), -1); 4826 } 4827 } 4828 4829 protected void composeClaimDiagnosisComponent(Complex parent, String parentType, String name, Claim.DiagnosisComponent element, int index) { 4830 if (element == null) 4831 return; 4832 Complex t; 4833 if (Utilities.noString(parentType)) 4834 t = parent; 4835 else { 4836 t = parent.predicate("fhir:"+parentType+'.'+name); 4837 } 4838 composeBackboneElement(t, "diagnosis", name, element, index); 4839 if (element.hasSequenceElement()) { 4840 composePositiveInt(t, "DiagnosisComponent", "sequence", element.getSequenceElement(), -1); 4841 } 4842 if (element.hasDiagnosis()) { 4843 composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1); 4844 } 4845 for (int i = 0; i < element.getType().size(); i++) { 4846 composeCodeableConcept(t, "DiagnosisComponent", "type", element.getType().get(i), i); 4847 } 4848 if (element.hasOnAdmission()) { 4849 composeCodeableConcept(t, "DiagnosisComponent", "onAdmission", element.getOnAdmission(), -1); 4850 } 4851 if (element.hasPackageCode()) { 4852 composeCodeableConcept(t, "DiagnosisComponent", "packageCode", element.getPackageCode(), -1); 4853 } 4854 } 4855 4856 protected void composeClaimProcedureComponent(Complex parent, String parentType, String name, Claim.ProcedureComponent element, int index) { 4857 if (element == null) 4858 return; 4859 Complex t; 4860 if (Utilities.noString(parentType)) 4861 t = parent; 4862 else { 4863 t = parent.predicate("fhir:"+parentType+'.'+name); 4864 } 4865 composeBackboneElement(t, "procedure", name, element, index); 4866 if (element.hasSequenceElement()) { 4867 composePositiveInt(t, "ProcedureComponent", "sequence", element.getSequenceElement(), -1); 4868 } 4869 for (int i = 0; i < element.getType().size(); i++) { 4870 composeCodeableConcept(t, "ProcedureComponent", "type", element.getType().get(i), i); 4871 } 4872 if (element.hasDateElement()) { 4873 composeDateTime(t, "ProcedureComponent", "date", element.getDateElement(), -1); 4874 } 4875 if (element.hasProcedure()) { 4876 composeType(t, "ProcedureComponent", "procedure", element.getProcedure(), -1); 4877 } 4878 for (int i = 0; i < element.getUdi().size(); i++) { 4879 composeReference(t, "ProcedureComponent", "udi", element.getUdi().get(i), i); 4880 } 4881 } 4882 4883 protected void composeClaimInsuranceComponent(Complex parent, String parentType, String name, Claim.InsuranceComponent element, int index) { 4884 if (element == null) 4885 return; 4886 Complex t; 4887 if (Utilities.noString(parentType)) 4888 t = parent; 4889 else { 4890 t = parent.predicate("fhir:"+parentType+'.'+name); 4891 } 4892 composeBackboneElement(t, "insurance", name, element, index); 4893 if (element.hasSequenceElement()) { 4894 composePositiveInt(t, "InsuranceComponent", "sequence", element.getSequenceElement(), -1); 4895 } 4896 if (element.hasFocalElement()) { 4897 composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1); 4898 } 4899 if (element.hasIdentifier()) { 4900 composeIdentifier(t, "InsuranceComponent", "identifier", element.getIdentifier(), -1); 4901 } 4902 if (element.hasCoverage()) { 4903 composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1); 4904 } 4905 if (element.hasBusinessArrangementElement()) { 4906 composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1); 4907 } 4908 for (int i = 0; i < element.getPreAuthRef().size(); i++) { 4909 composeString(t, "InsuranceComponent", "preAuthRef", element.getPreAuthRef().get(i), i); 4910 } 4911 if (element.hasClaimResponse()) { 4912 composeReference(t, "InsuranceComponent", "claimResponse", element.getClaimResponse(), -1); 4913 } 4914 } 4915 4916 protected void composeClaimAccidentComponent(Complex parent, String parentType, String name, Claim.AccidentComponent element, int index) { 4917 if (element == null) 4918 return; 4919 Complex t; 4920 if (Utilities.noString(parentType)) 4921 t = parent; 4922 else { 4923 t = parent.predicate("fhir:"+parentType+'.'+name); 4924 } 4925 composeBackboneElement(t, "accident", name, element, index); 4926 if (element.hasDateElement()) { 4927 composeDate(t, "AccidentComponent", "date", element.getDateElement(), -1); 4928 } 4929 if (element.hasType()) { 4930 composeCodeableConcept(t, "AccidentComponent", "type", element.getType(), -1); 4931 } 4932 if (element.hasLocation()) { 4933 composeType(t, "AccidentComponent", "location", element.getLocation(), -1); 4934 } 4935 } 4936 4937 protected void composeClaimItemComponent(Complex parent, String parentType, String name, Claim.ItemComponent element, int index) { 4938 if (element == null) 4939 return; 4940 Complex t; 4941 if (Utilities.noString(parentType)) 4942 t = parent; 4943 else { 4944 t = parent.predicate("fhir:"+parentType+'.'+name); 4945 } 4946 composeBackboneElement(t, "item", name, element, index); 4947 if (element.hasSequenceElement()) { 4948 composePositiveInt(t, "ItemComponent", "sequence", element.getSequenceElement(), -1); 4949 } 4950 for (int i = 0; i < element.getCareTeamSequence().size(); i++) { 4951 composePositiveInt(t, "ItemComponent", "careTeamSequence", element.getCareTeamSequence().get(i), i); 4952 } 4953 for (int i = 0; i < element.getDiagnosisSequence().size(); i++) { 4954 composePositiveInt(t, "ItemComponent", "diagnosisSequence", element.getDiagnosisSequence().get(i), i); 4955 } 4956 for (int i = 0; i < element.getProcedureSequence().size(); i++) { 4957 composePositiveInt(t, "ItemComponent", "procedureSequence", element.getProcedureSequence().get(i), i); 4958 } 4959 for (int i = 0; i < element.getInformationSequence().size(); i++) { 4960 composePositiveInt(t, "ItemComponent", "informationSequence", element.getInformationSequence().get(i), i); 4961 } 4962 if (element.hasRevenue()) { 4963 composeCodeableConcept(t, "ItemComponent", "revenue", element.getRevenue(), -1); 4964 } 4965 if (element.hasCategory()) { 4966 composeCodeableConcept(t, "ItemComponent", "category", element.getCategory(), -1); 4967 } 4968 if (element.hasProductOrService()) { 4969 composeCodeableConcept(t, "ItemComponent", "productOrService", element.getProductOrService(), -1); 4970 } 4971 for (int i = 0; i < element.getModifier().size(); i++) { 4972 composeCodeableConcept(t, "ItemComponent", "modifier", element.getModifier().get(i), i); 4973 } 4974 for (int i = 0; i < element.getProgramCode().size(); i++) { 4975 composeCodeableConcept(t, "ItemComponent", "programCode", element.getProgramCode().get(i), i); 4976 } 4977 if (element.hasServiced()) { 4978 composeType(t, "ItemComponent", "serviced", element.getServiced(), -1); 4979 } 4980 if (element.hasLocation()) { 4981 composeType(t, "ItemComponent", "location", element.getLocation(), -1); 4982 } 4983 if (element.hasQuantity()) { 4984 composeQuantity(t, "ItemComponent", "quantity", element.getQuantity(), -1); 4985 } 4986 if (element.hasUnitPrice()) { 4987 composeMoney(t, "ItemComponent", "unitPrice", element.getUnitPrice(), -1); 4988 } 4989 if (element.hasFactorElement()) { 4990 composeDecimal(t, "ItemComponent", "factor", element.getFactorElement(), -1); 4991 } 4992 if (element.hasNet()) { 4993 composeMoney(t, "ItemComponent", "net", element.getNet(), -1); 4994 } 4995 for (int i = 0; i < element.getUdi().size(); i++) { 4996 composeReference(t, "ItemComponent", "udi", element.getUdi().get(i), i); 4997 } 4998 if (element.hasBodySite()) { 4999 composeCodeableConcept(t, "ItemComponent", "bodySite", element.getBodySite(), -1); 5000 } 5001 for (int i = 0; i < element.getSubSite().size(); i++) { 5002 composeCodeableConcept(t, "ItemComponent", "subSite", element.getSubSite().get(i), i); 5003 } 5004 for (int i = 0; i < element.getEncounter().size(); i++) { 5005 composeReference(t, "ItemComponent", "encounter", element.getEncounter().get(i), i); 5006 } 5007 for (int i = 0; i < element.getDetail().size(); i++) { 5008 composeClaimDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i); 5009 } 5010 } 5011 5012 protected void composeClaimDetailComponent(Complex parent, String parentType, String name, Claim.DetailComponent element, int index) { 5013 if (element == null) 5014 return; 5015 Complex t; 5016 if (Utilities.noString(parentType)) 5017 t = parent; 5018 else { 5019 t = parent.predicate("fhir:"+parentType+'.'+name); 5020 } 5021 composeBackboneElement(t, "detail", name, element, index); 5022 if (element.hasSequenceElement()) { 5023 composePositiveInt(t, "DetailComponent", "sequence", element.getSequenceElement(), -1); 5024 } 5025 if (element.hasRevenue()) { 5026 composeCodeableConcept(t, "DetailComponent", "revenue", element.getRevenue(), -1); 5027 } 5028 if (element.hasCategory()) { 5029 composeCodeableConcept(t, "DetailComponent", "category", element.getCategory(), -1); 5030 } 5031 if (element.hasProductOrService()) { 5032 composeCodeableConcept(t, "DetailComponent", "productOrService", element.getProductOrService(), -1); 5033 } 5034 for (int i = 0; i < element.getModifier().size(); i++) { 5035 composeCodeableConcept(t, "DetailComponent", "modifier", element.getModifier().get(i), i); 5036 } 5037 for (int i = 0; i < element.getProgramCode().size(); i++) { 5038 composeCodeableConcept(t, "DetailComponent", "programCode", element.getProgramCode().get(i), i); 5039 } 5040 if (element.hasQuantity()) { 5041 composeQuantity(t, "DetailComponent", "quantity", element.getQuantity(), -1); 5042 } 5043 if (element.hasUnitPrice()) { 5044 composeMoney(t, "DetailComponent", "unitPrice", element.getUnitPrice(), -1); 5045 } 5046 if (element.hasFactorElement()) { 5047 composeDecimal(t, "DetailComponent", "factor", element.getFactorElement(), -1); 5048 } 5049 if (element.hasNet()) { 5050 composeMoney(t, "DetailComponent", "net", element.getNet(), -1); 5051 } 5052 for (int i = 0; i < element.getUdi().size(); i++) { 5053 composeReference(t, "DetailComponent", "udi", element.getUdi().get(i), i); 5054 } 5055 for (int i = 0; i < element.getSubDetail().size(); i++) { 5056 composeClaimSubDetailComponent(t, "DetailComponent", "subDetail", element.getSubDetail().get(i), i); 5057 } 5058 } 5059 5060 protected void composeClaimSubDetailComponent(Complex parent, String parentType, String name, Claim.SubDetailComponent element, int index) { 5061 if (element == null) 5062 return; 5063 Complex t; 5064 if (Utilities.noString(parentType)) 5065 t = parent; 5066 else { 5067 t = parent.predicate("fhir:"+parentType+'.'+name); 5068 } 5069 composeBackboneElement(t, "subDetail", name, element, index); 5070 if (element.hasSequenceElement()) { 5071 composePositiveInt(t, "SubDetailComponent", "sequence", element.getSequenceElement(), -1); 5072 } 5073 if (element.hasRevenue()) { 5074 composeCodeableConcept(t, "SubDetailComponent", "revenue", element.getRevenue(), -1); 5075 } 5076 if (element.hasCategory()) { 5077 composeCodeableConcept(t, "SubDetailComponent", "category", element.getCategory(), -1); 5078 } 5079 if (element.hasProductOrService()) { 5080 composeCodeableConcept(t, "SubDetailComponent", "productOrService", element.getProductOrService(), -1); 5081 } 5082 for (int i = 0; i < element.getModifier().size(); i++) { 5083 composeCodeableConcept(t, "SubDetailComponent", "modifier", element.getModifier().get(i), i); 5084 } 5085 for (int i = 0; i < element.getProgramCode().size(); i++) { 5086 composeCodeableConcept(t, "SubDetailComponent", "programCode", element.getProgramCode().get(i), i); 5087 } 5088 if (element.hasQuantity()) { 5089 composeQuantity(t, "SubDetailComponent", "quantity", element.getQuantity(), -1); 5090 } 5091 if (element.hasUnitPrice()) { 5092 composeMoney(t, "SubDetailComponent", "unitPrice", element.getUnitPrice(), -1); 5093 } 5094 if (element.hasFactorElement()) { 5095 composeDecimal(t, "SubDetailComponent", "factor", element.getFactorElement(), -1); 5096 } 5097 if (element.hasNet()) { 5098 composeMoney(t, "SubDetailComponent", "net", element.getNet(), -1); 5099 } 5100 for (int i = 0; i < element.getUdi().size(); i++) { 5101 composeReference(t, "SubDetailComponent", "udi", element.getUdi().get(i), i); 5102 } 5103 } 5104 5105 protected void composeClaimResponse(Complex parent, String parentType, String name, ClaimResponse element, int index) { 5106 if (element == null) 5107 return; 5108 Complex t; 5109 if (Utilities.noString(parentType)) 5110 t = parent; 5111 else { 5112 t = parent.predicate("fhir:"+parentType+'.'+name); 5113 } 5114 composeDomainResource(t, "ClaimResponse", name, element, index); 5115 for (int i = 0; i < element.getIdentifier().size(); i++) { 5116 composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier().get(i), i); 5117 } 5118 if (element.hasStatusElement()) { 5119 composeEnum(t, "ClaimResponse", "status", element.getStatusElement(), -1); 5120 } 5121 if (element.hasType()) { 5122 composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1); 5123 } 5124 if (element.hasSubType()) { 5125 composeCodeableConcept(t, "ClaimResponse", "subType", element.getSubType(), -1); 5126 } 5127 if (element.hasUseElement()) { 5128 composeEnum(t, "ClaimResponse", "use", element.getUseElement(), -1); 5129 } 5130 if (element.hasPatient()) { 5131 composeReference(t, "ClaimResponse", "patient", element.getPatient(), -1); 5132 } 5133 if (element.hasCreatedElement()) { 5134 composeDateTime(t, "ClaimResponse", "created", element.getCreatedElement(), -1); 5135 } 5136 if (element.hasInsurer()) { 5137 composeReference(t, "ClaimResponse", "insurer", element.getInsurer(), -1); 5138 } 5139 if (element.hasRequestor()) { 5140 composeReference(t, "ClaimResponse", "requestor", element.getRequestor(), -1); 5141 } 5142 if (element.hasRequest()) { 5143 composeReference(t, "ClaimResponse", "request", element.getRequest(), -1); 5144 } 5145 if (element.hasOutcomeElement()) { 5146 composeEnum(t, "ClaimResponse", "outcome", element.getOutcomeElement(), -1); 5147 } 5148 if (element.hasDispositionElement()) { 5149 composeString(t, "ClaimResponse", "disposition", element.getDispositionElement(), -1); 5150 } 5151 if (element.hasPreAuthRefElement()) { 5152 composeString(t, "ClaimResponse", "preAuthRef", element.getPreAuthRefElement(), -1); 5153 } 5154 if (element.hasPreAuthPeriod()) { 5155 composePeriod(t, "ClaimResponse", "preAuthPeriod", element.getPreAuthPeriod(), -1); 5156 } 5157 if (element.hasPayeeType()) { 5158 composeCodeableConcept(t, "ClaimResponse", "payeeType", element.getPayeeType(), -1); 5159 } 5160 for (int i = 0; i < element.getItem().size(); i++) { 5161 composeClaimResponseItemComponent(t, "ClaimResponse", "item", element.getItem().get(i), i); 5162 } 5163 for (int i = 0; i < element.getAddItem().size(); i++) { 5164 composeClaimResponseAddedItemComponent(t, "ClaimResponse", "addItem", element.getAddItem().get(i), i); 5165 } 5166 for (int i = 0; i < element.getAdjudication().size(); i++) { 5167 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 5168 } 5169 for (int i = 0; i < element.getTotal().size(); i++) { 5170 composeClaimResponseTotalComponent(t, "ClaimResponse", "total", element.getTotal().get(i), i); 5171 } 5172 if (element.hasPayment()) { 5173 composeClaimResponsePaymentComponent(t, "ClaimResponse", "payment", element.getPayment(), -1); 5174 } 5175 if (element.hasFundsReserve()) { 5176 composeCodeableConcept(t, "ClaimResponse", "fundsReserve", element.getFundsReserve(), -1); 5177 } 5178 if (element.hasFormCode()) { 5179 composeCodeableConcept(t, "ClaimResponse", "formCode", element.getFormCode(), -1); 5180 } 5181 if (element.hasForm()) { 5182 composeAttachment(t, "ClaimResponse", "form", element.getForm(), -1); 5183 } 5184 for (int i = 0; i < element.getProcessNote().size(); i++) { 5185 composeClaimResponseNoteComponent(t, "ClaimResponse", "processNote", element.getProcessNote().get(i), i); 5186 } 5187 for (int i = 0; i < element.getCommunicationRequest().size(); i++) { 5188 composeReference(t, "ClaimResponse", "communicationRequest", element.getCommunicationRequest().get(i), i); 5189 } 5190 for (int i = 0; i < element.getInsurance().size(); i++) { 5191 composeClaimResponseInsuranceComponent(t, "ClaimResponse", "insurance", element.getInsurance().get(i), i); 5192 } 5193 for (int i = 0; i < element.getError().size(); i++) { 5194 composeClaimResponseErrorComponent(t, "ClaimResponse", "error", element.getError().get(i), i); 5195 } 5196 } 5197 5198 protected void composeClaimResponseItemComponent(Complex parent, String parentType, String name, ClaimResponse.ItemComponent 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, "item", name, element, index); 5208 if (element.hasItemSequenceElement()) { 5209 composePositiveInt(t, "ItemComponent", "itemSequence", element.getItemSequenceElement(), -1); 5210 } 5211 for (int i = 0; i < element.getNoteNumber().size(); i++) { 5212 composePositiveInt(t, "ItemComponent", "noteNumber", element.getNoteNumber().get(i), i); 5213 } 5214 for (int i = 0; i < element.getAdjudication().size(); i++) { 5215 composeClaimResponseAdjudicationComponent(t, "ItemComponent", "adjudication", element.getAdjudication().get(i), i); 5216 } 5217 for (int i = 0; i < element.getDetail().size(); i++) { 5218 composeClaimResponseItemDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i); 5219 } 5220 } 5221 5222 protected void composeClaimResponseAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.AdjudicationComponent element, int index) { 5223 if (element == null) 5224 return; 5225 Complex t; 5226 if (Utilities.noString(parentType)) 5227 t = parent; 5228 else { 5229 t = parent.predicate("fhir:"+parentType+'.'+name); 5230 } 5231 composeBackboneElement(t, "adjudication", name, element, index); 5232 if (element.hasCategory()) { 5233 composeCodeableConcept(t, "AdjudicationComponent", "category", element.getCategory(), -1); 5234 } 5235 if (element.hasReason()) { 5236 composeCodeableConcept(t, "AdjudicationComponent", "reason", element.getReason(), -1); 5237 } 5238 if (element.hasAmount()) { 5239 composeMoney(t, "AdjudicationComponent", "amount", element.getAmount(), -1); 5240 } 5241 if (element.hasValueElement()) { 5242 composeDecimal(t, "AdjudicationComponent", "value", element.getValueElement(), -1); 5243 } 5244 } 5245 5246 protected void composeClaimResponseItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.ItemDetailComponent element, int index) { 5247 if (element == null) 5248 return; 5249 Complex t; 5250 if (Utilities.noString(parentType)) 5251 t = parent; 5252 else { 5253 t = parent.predicate("fhir:"+parentType+'.'+name); 5254 } 5255 composeBackboneElement(t, "detail", name, element, index); 5256 if (element.hasDetailSequenceElement()) { 5257 composePositiveInt(t, "ItemDetailComponent", "detailSequence", element.getDetailSequenceElement(), -1); 5258 } 5259 for (int i = 0; i < element.getNoteNumber().size(); i++) { 5260 composePositiveInt(t, "ItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i); 5261 } 5262 for (int i = 0; i < element.getAdjudication().size(); i++) { 5263 composeClaimResponseAdjudicationComponent(t, "ItemDetailComponent", "adjudication", element.getAdjudication().get(i), i); 5264 } 5265 for (int i = 0; i < element.getSubDetail().size(); i++) { 5266 composeClaimResponseSubDetailComponent(t, "ItemDetailComponent", "subDetail", element.getSubDetail().get(i), i); 5267 } 5268 } 5269 5270 protected void composeClaimResponseSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.SubDetailComponent element, int index) { 5271 if (element == null) 5272 return; 5273 Complex t; 5274 if (Utilities.noString(parentType)) 5275 t = parent; 5276 else { 5277 t = parent.predicate("fhir:"+parentType+'.'+name); 5278 } 5279 composeBackboneElement(t, "subDetail", name, element, index); 5280 if (element.hasSubDetailSequenceElement()) { 5281 composePositiveInt(t, "SubDetailComponent", "subDetailSequence", element.getSubDetailSequenceElement(), -1); 5282 } 5283 for (int i = 0; i < element.getNoteNumber().size(); i++) { 5284 composePositiveInt(t, "SubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i); 5285 } 5286 for (int i = 0; i < element.getAdjudication().size(); i++) { 5287 composeClaimResponseAdjudicationComponent(t, "SubDetailComponent", "adjudication", element.getAdjudication().get(i), i); 5288 } 5289 } 5290 5291 protected void composeClaimResponseAddedItemComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemComponent element, int index) { 5292 if (element == null) 5293 return; 5294 Complex t; 5295 if (Utilities.noString(parentType)) 5296 t = parent; 5297 else { 5298 t = parent.predicate("fhir:"+parentType+'.'+name); 5299 } 5300 composeBackboneElement(t, "addItem", name, element, index); 5301 for (int i = 0; i < element.getItemSequence().size(); i++) { 5302 composePositiveInt(t, "AddedItemComponent", "itemSequence", element.getItemSequence().get(i), i); 5303 } 5304 for (int i = 0; i < element.getDetailSequence().size(); i++) { 5305 composePositiveInt(t, "AddedItemComponent", "detailSequence", element.getDetailSequence().get(i), i); 5306 } 5307 for (int i = 0; i < element.getSubdetailSequence().size(); i++) { 5308 composePositiveInt(t, "AddedItemComponent", "subdetailSequence", element.getSubdetailSequence().get(i), i); 5309 } 5310 for (int i = 0; i < element.getProvider().size(); i++) { 5311 composeReference(t, "AddedItemComponent", "provider", element.getProvider().get(i), i); 5312 } 5313 if (element.hasProductOrService()) { 5314 composeCodeableConcept(t, "AddedItemComponent", "productOrService", element.getProductOrService(), -1); 5315 } 5316 for (int i = 0; i < element.getModifier().size(); i++) { 5317 composeCodeableConcept(t, "AddedItemComponent", "modifier", element.getModifier().get(i), i); 5318 } 5319 for (int i = 0; i < element.getProgramCode().size(); i++) { 5320 composeCodeableConcept(t, "AddedItemComponent", "programCode", element.getProgramCode().get(i), i); 5321 } 5322 if (element.hasServiced()) { 5323 composeType(t, "AddedItemComponent", "serviced", element.getServiced(), -1); 5324 } 5325 if (element.hasLocation()) { 5326 composeType(t, "AddedItemComponent", "location", element.getLocation(), -1); 5327 } 5328 if (element.hasQuantity()) { 5329 composeQuantity(t, "AddedItemComponent", "quantity", element.getQuantity(), -1); 5330 } 5331 if (element.hasUnitPrice()) { 5332 composeMoney(t, "AddedItemComponent", "unitPrice", element.getUnitPrice(), -1); 5333 } 5334 if (element.hasFactorElement()) { 5335 composeDecimal(t, "AddedItemComponent", "factor", element.getFactorElement(), -1); 5336 } 5337 if (element.hasNet()) { 5338 composeMoney(t, "AddedItemComponent", "net", element.getNet(), -1); 5339 } 5340 if (element.hasBodySite()) { 5341 composeCodeableConcept(t, "AddedItemComponent", "bodySite", element.getBodySite(), -1); 5342 } 5343 for (int i = 0; i < element.getSubSite().size(); i++) { 5344 composeCodeableConcept(t, "AddedItemComponent", "subSite", element.getSubSite().get(i), i); 5345 } 5346 for (int i = 0; i < element.getNoteNumber().size(); i++) { 5347 composePositiveInt(t, "AddedItemComponent", "noteNumber", element.getNoteNumber().get(i), i); 5348 } 5349 for (int i = 0; i < element.getAdjudication().size(); i++) { 5350 composeClaimResponseAdjudicationComponent(t, "AddedItemComponent", "adjudication", element.getAdjudication().get(i), i); 5351 } 5352 for (int i = 0; i < element.getDetail().size(); i++) { 5353 composeClaimResponseAddedItemDetailComponent(t, "AddedItemComponent", "detail", element.getDetail().get(i), i); 5354 } 5355 } 5356 5357 protected void composeClaimResponseAddedItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemDetailComponent element, int index) { 5358 if (element == null) 5359 return; 5360 Complex t; 5361 if (Utilities.noString(parentType)) 5362 t = parent; 5363 else { 5364 t = parent.predicate("fhir:"+parentType+'.'+name); 5365 } 5366 composeBackboneElement(t, "detail", name, element, index); 5367 if (element.hasProductOrService()) { 5368 composeCodeableConcept(t, "AddedItemDetailComponent", "productOrService", element.getProductOrService(), -1); 5369 } 5370 for (int i = 0; i < element.getModifier().size(); i++) { 5371 composeCodeableConcept(t, "AddedItemDetailComponent", "modifier", element.getModifier().get(i), i); 5372 } 5373 if (element.hasQuantity()) { 5374 composeQuantity(t, "AddedItemDetailComponent", "quantity", element.getQuantity(), -1); 5375 } 5376 if (element.hasUnitPrice()) { 5377 composeMoney(t, "AddedItemDetailComponent", "unitPrice", element.getUnitPrice(), -1); 5378 } 5379 if (element.hasFactorElement()) { 5380 composeDecimal(t, "AddedItemDetailComponent", "factor", element.getFactorElement(), -1); 5381 } 5382 if (element.hasNet()) { 5383 composeMoney(t, "AddedItemDetailComponent", "net", element.getNet(), -1); 5384 } 5385 for (int i = 0; i < element.getNoteNumber().size(); i++) { 5386 composePositiveInt(t, "AddedItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i); 5387 } 5388 for (int i = 0; i < element.getAdjudication().size(); i++) { 5389 composeClaimResponseAdjudicationComponent(t, "AddedItemDetailComponent", "adjudication", element.getAdjudication().get(i), i); 5390 } 5391 for (int i = 0; i < element.getSubDetail().size(); i++) { 5392 composeClaimResponseAddedItemSubDetailComponent(t, "AddedItemDetailComponent", "subDetail", element.getSubDetail().get(i), i); 5393 } 5394 } 5395 5396 protected void composeClaimResponseAddedItemSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemSubDetailComponent 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, "subDetail", name, element, index); 5406 if (element.hasProductOrService()) { 5407 composeCodeableConcept(t, "AddedItemSubDetailComponent", "productOrService", element.getProductOrService(), -1); 5408 } 5409 for (int i = 0; i < element.getModifier().size(); i++) { 5410 composeCodeableConcept(t, "AddedItemSubDetailComponent", "modifier", element.getModifier().get(i), i); 5411 } 5412 if (element.hasQuantity()) { 5413 composeQuantity(t, "AddedItemSubDetailComponent", "quantity", element.getQuantity(), -1); 5414 } 5415 if (element.hasUnitPrice()) { 5416 composeMoney(t, "AddedItemSubDetailComponent", "unitPrice", element.getUnitPrice(), -1); 5417 } 5418 if (element.hasFactorElement()) { 5419 composeDecimal(t, "AddedItemSubDetailComponent", "factor", element.getFactorElement(), -1); 5420 } 5421 if (element.hasNet()) { 5422 composeMoney(t, "AddedItemSubDetailComponent", "net", element.getNet(), -1); 5423 } 5424 for (int i = 0; i < element.getNoteNumber().size(); i++) { 5425 composePositiveInt(t, "AddedItemSubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i); 5426 } 5427 for (int i = 0; i < element.getAdjudication().size(); i++) { 5428 composeClaimResponseAdjudicationComponent(t, "AddedItemSubDetailComponent", "adjudication", element.getAdjudication().get(i), i); 5429 } 5430 } 5431 5432 protected void composeClaimResponseTotalComponent(Complex parent, String parentType, String name, ClaimResponse.TotalComponent 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, "total", name, element, index); 5442 if (element.hasCategory()) { 5443 composeCodeableConcept(t, "TotalComponent", "category", element.getCategory(), -1); 5444 } 5445 if (element.hasAmount()) { 5446 composeMoney(t, "TotalComponent", "amount", element.getAmount(), -1); 5447 } 5448 } 5449 5450 protected void composeClaimResponsePaymentComponent(Complex parent, String parentType, String name, ClaimResponse.PaymentComponent element, int index) { 5451 if (element == null) 5452 return; 5453 Complex t; 5454 if (Utilities.noString(parentType)) 5455 t = parent; 5456 else { 5457 t = parent.predicate("fhir:"+parentType+'.'+name); 5458 } 5459 composeBackboneElement(t, "payment", name, element, index); 5460 if (element.hasType()) { 5461 composeCodeableConcept(t, "PaymentComponent", "type", element.getType(), -1); 5462 } 5463 if (element.hasAdjustment()) { 5464 composeMoney(t, "PaymentComponent", "adjustment", element.getAdjustment(), -1); 5465 } 5466 if (element.hasAdjustmentReason()) { 5467 composeCodeableConcept(t, "PaymentComponent", "adjustmentReason", element.getAdjustmentReason(), -1); 5468 } 5469 if (element.hasDateElement()) { 5470 composeDate(t, "PaymentComponent", "date", element.getDateElement(), -1); 5471 } 5472 if (element.hasAmount()) { 5473 composeMoney(t, "PaymentComponent", "amount", element.getAmount(), -1); 5474 } 5475 if (element.hasIdentifier()) { 5476 composeIdentifier(t, "PaymentComponent", "identifier", element.getIdentifier(), -1); 5477 } 5478 } 5479 5480 protected void composeClaimResponseNoteComponent(Complex parent, String parentType, String name, ClaimResponse.NoteComponent element, int index) { 5481 if (element == null) 5482 return; 5483 Complex t; 5484 if (Utilities.noString(parentType)) 5485 t = parent; 5486 else { 5487 t = parent.predicate("fhir:"+parentType+'.'+name); 5488 } 5489 composeBackboneElement(t, "processNote", name, element, index); 5490 if (element.hasNumberElement()) { 5491 composePositiveInt(t, "NoteComponent", "number", element.getNumberElement(), -1); 5492 } 5493 if (element.hasTypeElement()) { 5494 composeEnum(t, "NoteComponent", "type", element.getTypeElement(), -1); 5495 } 5496 if (element.hasTextElement()) { 5497 composeString(t, "NoteComponent", "text", element.getTextElement(), -1); 5498 } 5499 if (element.hasLanguage()) { 5500 composeCodeableConcept(t, "NoteComponent", "language", element.getLanguage(), -1); 5501 } 5502 } 5503 5504 protected void composeClaimResponseInsuranceComponent(Complex parent, String parentType, String name, ClaimResponse.InsuranceComponent element, int index) { 5505 if (element == null) 5506 return; 5507 Complex t; 5508 if (Utilities.noString(parentType)) 5509 t = parent; 5510 else { 5511 t = parent.predicate("fhir:"+parentType+'.'+name); 5512 } 5513 composeBackboneElement(t, "insurance", name, element, index); 5514 if (element.hasSequenceElement()) { 5515 composePositiveInt(t, "InsuranceComponent", "sequence", element.getSequenceElement(), -1); 5516 } 5517 if (element.hasFocalElement()) { 5518 composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1); 5519 } 5520 if (element.hasCoverage()) { 5521 composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1); 5522 } 5523 if (element.hasBusinessArrangementElement()) { 5524 composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1); 5525 } 5526 if (element.hasClaimResponse()) { 5527 composeReference(t, "InsuranceComponent", "claimResponse", element.getClaimResponse(), -1); 5528 } 5529 } 5530 5531 protected void composeClaimResponseErrorComponent(Complex parent, String parentType, String name, ClaimResponse.ErrorComponent element, int index) { 5532 if (element == null) 5533 return; 5534 Complex t; 5535 if (Utilities.noString(parentType)) 5536 t = parent; 5537 else { 5538 t = parent.predicate("fhir:"+parentType+'.'+name); 5539 } 5540 composeBackboneElement(t, "error", name, element, index); 5541 if (element.hasItemSequenceElement()) { 5542 composePositiveInt(t, "ErrorComponent", "itemSequence", element.getItemSequenceElement(), -1); 5543 } 5544 if (element.hasDetailSequenceElement()) { 5545 composePositiveInt(t, "ErrorComponent", "detailSequence", element.getDetailSequenceElement(), -1); 5546 } 5547 if (element.hasSubDetailSequenceElement()) { 5548 composePositiveInt(t, "ErrorComponent", "subDetailSequence", element.getSubDetailSequenceElement(), -1); 5549 } 5550 if (element.hasCode()) { 5551 composeCodeableConcept(t, "ErrorComponent", "code", element.getCode(), -1); 5552 } 5553 } 5554 5555 protected void composeClinicalImpression(Complex parent, String parentType, String name, ClinicalImpression element, int index) { 5556 if (element == null) 5557 return; 5558 Complex t; 5559 if (Utilities.noString(parentType)) 5560 t = parent; 5561 else { 5562 t = parent.predicate("fhir:"+parentType+'.'+name); 5563 } 5564 composeDomainResource(t, "ClinicalImpression", name, element, index); 5565 for (int i = 0; i < element.getIdentifier().size(); i++) { 5566 composeIdentifier(t, "ClinicalImpression", "identifier", element.getIdentifier().get(i), i); 5567 } 5568 if (element.hasStatusElement()) { 5569 composeEnum(t, "ClinicalImpression", "status", element.getStatusElement(), -1); 5570 } 5571 if (element.hasStatusReason()) { 5572 composeCodeableConcept(t, "ClinicalImpression", "statusReason", element.getStatusReason(), -1); 5573 } 5574 if (element.hasDescriptionElement()) { 5575 composeString(t, "ClinicalImpression", "description", element.getDescriptionElement(), -1); 5576 } 5577 if (element.hasSubject()) { 5578 composeReference(t, "ClinicalImpression", "subject", element.getSubject(), -1); 5579 } 5580 if (element.hasEncounter()) { 5581 composeReference(t, "ClinicalImpression", "encounter", element.getEncounter(), -1); 5582 } 5583 if (element.hasEffective()) { 5584 composeType(t, "ClinicalImpression", "effective", element.getEffective(), -1); 5585 } 5586 if (element.hasDateElement()) { 5587 composeDateTime(t, "ClinicalImpression", "date", element.getDateElement(), -1); 5588 } 5589 if (element.hasPerformer()) { 5590 composeReference(t, "ClinicalImpression", "performer", element.getPerformer(), -1); 5591 } 5592 if (element.hasPrevious()) { 5593 composeReference(t, "ClinicalImpression", "previous", element.getPrevious(), -1); 5594 } 5595 for (int i = 0; i < element.getProblem().size(); i++) { 5596 composeReference(t, "ClinicalImpression", "problem", element.getProblem().get(i), i); 5597 } 5598 for (int i = 0; i < element.getProtocol().size(); i++) { 5599 composeUri(t, "ClinicalImpression", "protocol", element.getProtocol().get(i), i); 5600 } 5601 if (element.hasSummaryElement()) { 5602 composeString(t, "ClinicalImpression", "summary", element.getSummaryElement(), -1); 5603 } 5604 for (int i = 0; i < element.getFinding().size(); i++) { 5605 composeClinicalImpressionFindingComponent(t, "ClinicalImpression", "finding", element.getFinding().get(i), i); 5606 } 5607 for (int i = 0; i < element.getPrognosisCodeableConcept().size(); i++) { 5608 composeCodeableConcept(t, "ClinicalImpression", "prognosisCodeableConcept", element.getPrognosisCodeableConcept().get(i), i); 5609 } 5610 for (int i = 0; i < element.getPrognosisReference().size(); i++) { 5611 composeReference(t, "ClinicalImpression", "prognosisReference", element.getPrognosisReference().get(i), i); 5612 } 5613 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 5614 composeReference(t, "ClinicalImpression", "supportingInfo", element.getSupportingInfo().get(i), i); 5615 } 5616 for (int i = 0; i < element.getNote().size(); i++) { 5617 composeAnnotation(t, "ClinicalImpression", "note", element.getNote().get(i), i); 5618 } 5619 } 5620 5621 protected void composeClinicalImpressionFindingComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionFindingComponent element, int index) { 5622 if (element == null) 5623 return; 5624 Complex t; 5625 if (Utilities.noString(parentType)) 5626 t = parent; 5627 else { 5628 t = parent.predicate("fhir:"+parentType+'.'+name); 5629 } 5630 composeBackboneElement(t, "finding", name, element, index); 5631 if (element.hasItem()) { 5632 composeCodeableReference(t, "ClinicalImpressionFindingComponent", "item", element.getItem(), -1); 5633 } 5634 if (element.hasBasisElement()) { 5635 composeString(t, "ClinicalImpressionFindingComponent", "basis", element.getBasisElement(), -1); 5636 } 5637 } 5638 5639 protected void composeClinicalUseIssue(Complex parent, String parentType, String name, ClinicalUseIssue element, int index) { 5640 if (element == null) 5641 return; 5642 Complex t; 5643 if (Utilities.noString(parentType)) 5644 t = parent; 5645 else { 5646 t = parent.predicate("fhir:"+parentType+'.'+name); 5647 } 5648 composeDomainResource(t, "ClinicalUseIssue", name, element, index); 5649 for (int i = 0; i < element.getIdentifier().size(); i++) { 5650 composeIdentifier(t, "ClinicalUseIssue", "identifier", element.getIdentifier().get(i), i); 5651 } 5652 if (element.hasTypeElement()) { 5653 composeEnum(t, "ClinicalUseIssue", "type", element.getTypeElement(), -1); 5654 } 5655 for (int i = 0; i < element.getSubject().size(); i++) { 5656 composeReference(t, "ClinicalUseIssue", "subject", element.getSubject().get(i), i); 5657 } 5658 if (element.hasStatus()) { 5659 composeCodeableConcept(t, "ClinicalUseIssue", "status", element.getStatus(), -1); 5660 } 5661 if (element.hasDescriptionElement()) { 5662 composeMarkdown(t, "ClinicalUseIssue", "description", element.getDescriptionElement(), -1); 5663 } 5664 if (element.hasContraindication()) { 5665 composeClinicalUseIssueContraindicationComponent(t, "ClinicalUseIssue", "contraindication", element.getContraindication(), -1); 5666 } 5667 if (element.hasIndication()) { 5668 composeClinicalUseIssueIndicationComponent(t, "ClinicalUseIssue", "indication", element.getIndication(), -1); 5669 } 5670 if (element.hasInteraction()) { 5671 composeClinicalUseIssueInteractionComponent(t, "ClinicalUseIssue", "interaction", element.getInteraction(), -1); 5672 } 5673 for (int i = 0; i < element.getPopulation().size(); i++) { 5674 composePopulation(t, "ClinicalUseIssue", "population", element.getPopulation().get(i), i); 5675 } 5676 if (element.hasUndesirableEffect()) { 5677 composeClinicalUseIssueUndesirableEffectComponent(t, "ClinicalUseIssue", "undesirableEffect", element.getUndesirableEffect(), -1); 5678 } 5679 } 5680 5681 protected void composeClinicalUseIssueContraindicationComponent(Complex parent, String parentType, String name, ClinicalUseIssue.ClinicalUseIssueContraindicationComponent element, int index) { 5682 if (element == null) 5683 return; 5684 Complex t; 5685 if (Utilities.noString(parentType)) 5686 t = parent; 5687 else { 5688 t = parent.predicate("fhir:"+parentType+'.'+name); 5689 } 5690 composeBackboneElement(t, "contraindication", name, element, index); 5691 if (element.hasDiseaseSymptomProcedure()) { 5692 composeCodeableConcept(t, "ClinicalUseIssueContraindicationComponent", "diseaseSymptomProcedure", element.getDiseaseSymptomProcedure(), -1); 5693 } 5694 if (element.hasDiseaseStatus()) { 5695 composeCodeableConcept(t, "ClinicalUseIssueContraindicationComponent", "diseaseStatus", element.getDiseaseStatus(), -1); 5696 } 5697 for (int i = 0; i < element.getComorbidity().size(); i++) { 5698 composeCodeableConcept(t, "ClinicalUseIssueContraindicationComponent", "comorbidity", element.getComorbidity().get(i), i); 5699 } 5700 for (int i = 0; i < element.getIndication().size(); i++) { 5701 composeReference(t, "ClinicalUseIssueContraindicationComponent", "indication", element.getIndication().get(i), i); 5702 } 5703 for (int i = 0; i < element.getOtherTherapy().size(); i++) { 5704 composeClinicalUseIssueContraindicationOtherTherapyComponent(t, "ClinicalUseIssueContraindicationComponent", "otherTherapy", element.getOtherTherapy().get(i), i); 5705 } 5706 } 5707 5708 protected void composeClinicalUseIssueContraindicationOtherTherapyComponent(Complex parent, String parentType, String name, ClinicalUseIssue.ClinicalUseIssueContraindicationOtherTherapyComponent element, int index) { 5709 if (element == null) 5710 return; 5711 Complex t; 5712 if (Utilities.noString(parentType)) 5713 t = parent; 5714 else { 5715 t = parent.predicate("fhir:"+parentType+'.'+name); 5716 } 5717 composeBackboneElement(t, "otherTherapy", name, element, index); 5718 if (element.hasTherapyRelationshipType()) { 5719 composeCodeableConcept(t, "ClinicalUseIssueContraindicationOtherTherapyComponent", "therapyRelationshipType", element.getTherapyRelationshipType(), -1); 5720 } 5721 if (element.hasMedication()) { 5722 composeType(t, "ClinicalUseIssueContraindicationOtherTherapyComponent", "medication", element.getMedication(), -1); 5723 } 5724 } 5725 5726 protected void composeClinicalUseIssueIndicationComponent(Complex parent, String parentType, String name, ClinicalUseIssue.ClinicalUseIssueIndicationComponent element, int index) { 5727 if (element == null) 5728 return; 5729 Complex t; 5730 if (Utilities.noString(parentType)) 5731 t = parent; 5732 else { 5733 t = parent.predicate("fhir:"+parentType+'.'+name); 5734 } 5735 composeBackboneElement(t, "indication", name, element, index); 5736 if (element.hasDiseaseSymptomProcedure()) { 5737 composeCodeableConcept(t, "ClinicalUseIssueIndicationComponent", "diseaseSymptomProcedure", element.getDiseaseSymptomProcedure(), -1); 5738 } 5739 if (element.hasDiseaseStatus()) { 5740 composeCodeableConcept(t, "ClinicalUseIssueIndicationComponent", "diseaseStatus", element.getDiseaseStatus(), -1); 5741 } 5742 for (int i = 0; i < element.getComorbidity().size(); i++) { 5743 composeCodeableConcept(t, "ClinicalUseIssueIndicationComponent", "comorbidity", element.getComorbidity().get(i), i); 5744 } 5745 if (element.hasIntendedEffect()) { 5746 composeCodeableConcept(t, "ClinicalUseIssueIndicationComponent", "intendedEffect", element.getIntendedEffect(), -1); 5747 } 5748 if (element.hasDuration()) { 5749 composeQuantity(t, "ClinicalUseIssueIndicationComponent", "duration", element.getDuration(), -1); 5750 } 5751 for (int i = 0; i < element.getUndesirableEffect().size(); i++) { 5752 composeReference(t, "ClinicalUseIssueIndicationComponent", "undesirableEffect", element.getUndesirableEffect().get(i), i); 5753 } 5754 for (int i = 0; i < element.getOtherTherapy().size(); i++) { 5755 composeClinicalUseIssueContraindicationOtherTherapyComponent(t, "ClinicalUseIssueIndicationComponent", "otherTherapy", element.getOtherTherapy().get(i), i); 5756 } 5757 } 5758 5759 protected void composeClinicalUseIssueInteractionComponent(Complex parent, String parentType, String name, ClinicalUseIssue.ClinicalUseIssueInteractionComponent element, int index) { 5760 if (element == null) 5761 return; 5762 Complex t; 5763 if (Utilities.noString(parentType)) 5764 t = parent; 5765 else { 5766 t = parent.predicate("fhir:"+parentType+'.'+name); 5767 } 5768 composeBackboneElement(t, "interaction", name, element, index); 5769 for (int i = 0; i < element.getInteractant().size(); i++) { 5770 composeClinicalUseIssueInteractionInteractantComponent(t, "ClinicalUseIssueInteractionComponent", "interactant", element.getInteractant().get(i), i); 5771 } 5772 if (element.hasType()) { 5773 composeCodeableConcept(t, "ClinicalUseIssueInteractionComponent", "type", element.getType(), -1); 5774 } 5775 if (element.hasEffect()) { 5776 composeCodeableConcept(t, "ClinicalUseIssueInteractionComponent", "effect", element.getEffect(), -1); 5777 } 5778 if (element.hasIncidence()) { 5779 composeCodeableConcept(t, "ClinicalUseIssueInteractionComponent", "incidence", element.getIncidence(), -1); 5780 } 5781 if (element.hasManagement()) { 5782 composeCodeableConcept(t, "ClinicalUseIssueInteractionComponent", "management", element.getManagement(), -1); 5783 } 5784 } 5785 5786 protected void composeClinicalUseIssueInteractionInteractantComponent(Complex parent, String parentType, String name, ClinicalUseIssue.ClinicalUseIssueInteractionInteractantComponent 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, "interactant", name, element, index); 5796 if (element.hasItem()) { 5797 composeType(t, "ClinicalUseIssueInteractionInteractantComponent", "item", element.getItem(), -1); 5798 } 5799 } 5800 5801 protected void composeClinicalUseIssueUndesirableEffectComponent(Complex parent, String parentType, String name, ClinicalUseIssue.ClinicalUseIssueUndesirableEffectComponent element, int index) { 5802 if (element == null) 5803 return; 5804 Complex t; 5805 if (Utilities.noString(parentType)) 5806 t = parent; 5807 else { 5808 t = parent.predicate("fhir:"+parentType+'.'+name); 5809 } 5810 composeBackboneElement(t, "undesirableEffect", name, element, index); 5811 if (element.hasSymptomConditionEffect()) { 5812 composeCodeableConcept(t, "ClinicalUseIssueUndesirableEffectComponent", "symptomConditionEffect", element.getSymptomConditionEffect(), -1); 5813 } 5814 if (element.hasClassification()) { 5815 composeCodeableConcept(t, "ClinicalUseIssueUndesirableEffectComponent", "classification", element.getClassification(), -1); 5816 } 5817 if (element.hasFrequencyOfOccurrence()) { 5818 composeCodeableConcept(t, "ClinicalUseIssueUndesirableEffectComponent", "frequencyOfOccurrence", element.getFrequencyOfOccurrence(), -1); 5819 } 5820 } 5821 5822 protected void composeCodeSystem(Complex parent, String parentType, String name, CodeSystem element, int index) { 5823 if (element == null) 5824 return; 5825 Complex t; 5826 if (Utilities.noString(parentType)) 5827 t = parent; 5828 else { 5829 t = parent.predicate("fhir:"+parentType+'.'+name); 5830 } 5831 composeCanonicalResource(t, "CodeSystem", name, element, index); 5832 if (element.hasUrlElement()) { 5833 composeUri(t, "CodeSystem", "url", element.getUrlElement(), -1); 5834 } 5835 for (int i = 0; i < element.getIdentifier().size(); i++) { 5836 composeIdentifier(t, "CodeSystem", "identifier", element.getIdentifier().get(i), i); 5837 } 5838 if (element.hasVersionElement()) { 5839 composeString(t, "CodeSystem", "version", element.getVersionElement(), -1); 5840 } 5841 if (element.hasNameElement()) { 5842 composeString(t, "CodeSystem", "name", element.getNameElement(), -1); 5843 } 5844 if (element.hasTitleElement()) { 5845 composeString(t, "CodeSystem", "title", element.getTitleElement(), -1); 5846 } 5847 if (element.hasStatusElement()) { 5848 composeEnum(t, "CodeSystem", "status", element.getStatusElement(), -1); 5849 } 5850 if (element.hasExperimentalElement()) { 5851 composeBoolean(t, "CodeSystem", "experimental", element.getExperimentalElement(), -1); 5852 } 5853 if (element.hasDateElement()) { 5854 composeDateTime(t, "CodeSystem", "date", element.getDateElement(), -1); 5855 } 5856 if (element.hasPublisherElement()) { 5857 composeString(t, "CodeSystem", "publisher", element.getPublisherElement(), -1); 5858 } 5859 for (int i = 0; i < element.getContact().size(); i++) { 5860 composeContactDetail(t, "CodeSystem", "contact", element.getContact().get(i), i); 5861 } 5862 if (element.hasDescriptionElement()) { 5863 composeMarkdown(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 5864 } 5865 for (int i = 0; i < element.getUseContext().size(); i++) { 5866 composeUsageContext(t, "CodeSystem", "useContext", element.getUseContext().get(i), i); 5867 } 5868 for (int i = 0; i < element.getJurisdiction().size(); i++) { 5869 composeCodeableConcept(t, "CodeSystem", "jurisdiction", element.getJurisdiction().get(i), i); 5870 } 5871 if (element.hasPurposeElement()) { 5872 composeMarkdown(t, "CodeSystem", "purpose", element.getPurposeElement(), -1); 5873 } 5874 if (element.hasCopyrightElement()) { 5875 composeMarkdown(t, "CodeSystem", "copyright", element.getCopyrightElement(), -1); 5876 } 5877 if (element.hasCaseSensitiveElement()) { 5878 composeBoolean(t, "CodeSystem", "caseSensitive", element.getCaseSensitiveElement(), -1); 5879 } 5880 if (element.hasValueSetElement()) { 5881 composeCanonical(t, "CodeSystem", "valueSet", element.getValueSetElement(), -1); 5882 } 5883 if (element.hasHierarchyMeaningElement()) { 5884 composeEnum(t, "CodeSystem", "hierarchyMeaning", element.getHierarchyMeaningElement(), -1); 5885 } 5886 if (element.hasCompositionalElement()) { 5887 composeBoolean(t, "CodeSystem", "compositional", element.getCompositionalElement(), -1); 5888 } 5889 if (element.hasVersionNeededElement()) { 5890 composeBoolean(t, "CodeSystem", "versionNeeded", element.getVersionNeededElement(), -1); 5891 } 5892 if (element.hasContentElement()) { 5893 composeEnum(t, "CodeSystem", "content", element.getContentElement(), -1); 5894 } 5895 if (element.hasSupplementsElement()) { 5896 composeCanonical(t, "CodeSystem", "supplements", element.getSupplementsElement(), -1); 5897 } 5898 if (element.hasCountElement()) { 5899 composeUnsignedInt(t, "CodeSystem", "count", element.getCountElement(), -1); 5900 } 5901 for (int i = 0; i < element.getFilter().size(); i++) { 5902 composeCodeSystemFilterComponent(t, "CodeSystem", "filter", element.getFilter().get(i), i); 5903 } 5904 for (int i = 0; i < element.getProperty().size(); i++) { 5905 composeCodeSystemPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i); 5906 } 5907 for (int i = 0; i < element.getConcept().size(); i++) { 5908 composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i); 5909 } 5910 } 5911 5912 protected void composeCodeSystemFilterComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemFilterComponent 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, "filter", name, element, index); 5922 if (element.hasCodeElement()) { 5923 composeCode(t, "CodeSystemFilterComponent", "code", element.getCodeElement(), -1); 5924 } 5925 if (element.hasDescriptionElement()) { 5926 composeString(t, "CodeSystemFilterComponent", "description", element.getDescriptionElement(), -1); 5927 } 5928 for (int i = 0; i < element.getOperator().size(); i++) { 5929 composeEnum(t, "CodeSystemFilterComponent", "operator", element.getOperator().get(i), i); 5930 } 5931 if (element.hasValueElement()) { 5932 composeString(t, "CodeSystemFilterComponent", "value", element.getValueElement(), -1); 5933 } 5934 } 5935 5936 protected void composeCodeSystemPropertyComponent(Complex parent, String parentType, String name, CodeSystem.PropertyComponent element, int index) { 5937 if (element == null) 5938 return; 5939 Complex t; 5940 if (Utilities.noString(parentType)) 5941 t = parent; 5942 else { 5943 t = parent.predicate("fhir:"+parentType+'.'+name); 5944 } 5945 composeBackboneElement(t, "property", name, element, index); 5946 if (element.hasCodeElement()) { 5947 composeCode(t, "PropertyComponent", "code", element.getCodeElement(), -1); 5948 } 5949 if (element.hasUriElement()) { 5950 composeUri(t, "PropertyComponent", "uri", element.getUriElement(), -1); 5951 } 5952 if (element.hasDescriptionElement()) { 5953 composeString(t, "PropertyComponent", "description", element.getDescriptionElement(), -1); 5954 } 5955 if (element.hasTypeElement()) { 5956 composeEnum(t, "PropertyComponent", "type", element.getTypeElement(), -1); 5957 } 5958 } 5959 5960 protected void composeCodeSystemConceptDefinitionComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionComponent 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, "concept", name, element, index); 5970 if (element.hasCodeElement()) { 5971 composeCode(t, "ConceptDefinitionComponent", "code", element.getCodeElement(), -1); 5972 } 5973 if (element.hasDisplayElement()) { 5974 composeString(t, "ConceptDefinitionComponent", "display", element.getDisplayElement(), -1); 5975 } 5976 if (element.hasDefinitionElement()) { 5977 composeString(t, "ConceptDefinitionComponent", "definition", element.getDefinitionElement(), -1); 5978 } 5979 for (int i = 0; i < element.getDesignation().size(); i++) { 5980 composeCodeSystemConceptDefinitionDesignationComponent(t, "ConceptDefinitionComponent", "designation", element.getDesignation().get(i), i); 5981 } 5982 for (int i = 0; i < element.getProperty().size(); i++) { 5983 composeCodeSystemConceptPropertyComponent(t, "ConceptDefinitionComponent", "property", element.getProperty().get(i), i); 5984 } 5985 for (int i = 0; i < element.getConcept().size(); i++) { 5986 composeCodeSystemConceptDefinitionComponent(t, "ConceptDefinitionComponent", "concept", element.getConcept().get(i), i); 5987 } 5988 } 5989 5990 protected void composeCodeSystemConceptDefinitionDesignationComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionDesignationComponent element, int index) { 5991 if (element == null) 5992 return; 5993 Complex t; 5994 if (Utilities.noString(parentType)) 5995 t = parent; 5996 else { 5997 t = parent.predicate("fhir:"+parentType+'.'+name); 5998 } 5999 composeBackboneElement(t, "designation", name, element, index); 6000 if (element.hasLanguageElement()) { 6001 composeCode(t, "ConceptDefinitionDesignationComponent", "language", element.getLanguageElement(), -1); 6002 } 6003 if (element.hasUse()) { 6004 composeCoding(t, "ConceptDefinitionDesignationComponent", "use", element.getUse(), -1); 6005 } 6006 if (element.hasValueElement()) { 6007 composeString(t, "ConceptDefinitionDesignationComponent", "value", element.getValueElement(), -1); 6008 } 6009 } 6010 6011 protected void composeCodeSystemConceptPropertyComponent(Complex parent, String parentType, String name, CodeSystem.ConceptPropertyComponent element, int index) { 6012 if (element == null) 6013 return; 6014 Complex t; 6015 if (Utilities.noString(parentType)) 6016 t = parent; 6017 else { 6018 t = parent.predicate("fhir:"+parentType+'.'+name); 6019 } 6020 composeBackboneElement(t, "property", name, element, index); 6021 if (element.hasCodeElement()) { 6022 composeCode(t, "ConceptPropertyComponent", "code", element.getCodeElement(), -1); 6023 } 6024 if (element.hasValue()) { 6025 composeType(t, "ConceptPropertyComponent", "value", element.getValue(), -1); 6026 } 6027 } 6028 6029 protected void composeCommunication(Complex parent, String parentType, String name, Communication element, int index) { 6030 if (element == null) 6031 return; 6032 Complex t; 6033 if (Utilities.noString(parentType)) 6034 t = parent; 6035 else { 6036 t = parent.predicate("fhir:"+parentType+'.'+name); 6037 } 6038 composeDomainResource(t, "Communication", name, element, index); 6039 for (int i = 0; i < element.getIdentifier().size(); i++) { 6040 composeIdentifier(t, "Communication", "identifier", element.getIdentifier().get(i), i); 6041 } 6042 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) { 6043 composeCanonical(t, "Communication", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 6044 } 6045 for (int i = 0; i < element.getInstantiatesUri().size(); i++) { 6046 composeUri(t, "Communication", "instantiatesUri", element.getInstantiatesUri().get(i), i); 6047 } 6048 for (int i = 0; i < element.getBasedOn().size(); i++) { 6049 composeReference(t, "Communication", "basedOn", element.getBasedOn().get(i), i); 6050 } 6051 for (int i = 0; i < element.getPartOf().size(); i++) { 6052 composeReference(t, "Communication", "partOf", element.getPartOf().get(i), i); 6053 } 6054 for (int i = 0; i < element.getInResponseTo().size(); i++) { 6055 composeReference(t, "Communication", "inResponseTo", element.getInResponseTo().get(i), i); 6056 } 6057 if (element.hasStatusElement()) { 6058 composeEnum(t, "Communication", "status", element.getStatusElement(), -1); 6059 } 6060 if (element.hasStatusReason()) { 6061 composeCodeableConcept(t, "Communication", "statusReason", element.getStatusReason(), -1); 6062 } 6063 for (int i = 0; i < element.getCategory().size(); i++) { 6064 composeCodeableConcept(t, "Communication", "category", element.getCategory().get(i), i); 6065 } 6066 if (element.hasPriorityElement()) { 6067 composeEnum(t, "Communication", "priority", element.getPriorityElement(), -1); 6068 } 6069 for (int i = 0; i < element.getMedium().size(); i++) { 6070 composeCodeableConcept(t, "Communication", "medium", element.getMedium().get(i), i); 6071 } 6072 if (element.hasSubject()) { 6073 composeReference(t, "Communication", "subject", element.getSubject(), -1); 6074 } 6075 if (element.hasTopic()) { 6076 composeCodeableConcept(t, "Communication", "topic", element.getTopic(), -1); 6077 } 6078 for (int i = 0; i < element.getAbout().size(); i++) { 6079 composeReference(t, "Communication", "about", element.getAbout().get(i), i); 6080 } 6081 if (element.hasEncounter()) { 6082 composeReference(t, "Communication", "encounter", element.getEncounter(), -1); 6083 } 6084 if (element.hasSentElement()) { 6085 composeDateTime(t, "Communication", "sent", element.getSentElement(), -1); 6086 } 6087 if (element.hasReceivedElement()) { 6088 composeDateTime(t, "Communication", "received", element.getReceivedElement(), -1); 6089 } 6090 for (int i = 0; i < element.getRecipient().size(); i++) { 6091 composeReference(t, "Communication", "recipient", element.getRecipient().get(i), i); 6092 } 6093 if (element.hasSender()) { 6094 composeReference(t, "Communication", "sender", element.getSender(), -1); 6095 } 6096 for (int i = 0; i < element.getReason().size(); i++) { 6097 composeCodeableReference(t, "Communication", "reason", element.getReason().get(i), i); 6098 } 6099 for (int i = 0; i < element.getPayload().size(); i++) { 6100 composeCommunicationPayloadComponent(t, "Communication", "payload", element.getPayload().get(i), i); 6101 } 6102 for (int i = 0; i < element.getNote().size(); i++) { 6103 composeAnnotation(t, "Communication", "note", element.getNote().get(i), i); 6104 } 6105 } 6106 6107 protected void composeCommunicationPayloadComponent(Complex parent, String parentType, String name, Communication.CommunicationPayloadComponent element, int index) { 6108 if (element == null) 6109 return; 6110 Complex t; 6111 if (Utilities.noString(parentType)) 6112 t = parent; 6113 else { 6114 t = parent.predicate("fhir:"+parentType+'.'+name); 6115 } 6116 composeBackboneElement(t, "payload", name, element, index); 6117 if (element.hasContent()) { 6118 composeType(t, "CommunicationPayloadComponent", "content", element.getContent(), -1); 6119 } 6120 } 6121 6122 protected void composeCommunicationRequest(Complex parent, String parentType, String name, CommunicationRequest 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, "CommunicationRequest", name, element, index); 6132 for (int i = 0; i < element.getIdentifier().size(); i++) { 6133 composeIdentifier(t, "CommunicationRequest", "identifier", element.getIdentifier().get(i), i); 6134 } 6135 for (int i = 0; i < element.getBasedOn().size(); i++) { 6136 composeReference(t, "CommunicationRequest", "basedOn", element.getBasedOn().get(i), i); 6137 } 6138 for (int i = 0; i < element.getReplaces().size(); i++) { 6139 composeReference(t, "CommunicationRequest", "replaces", element.getReplaces().get(i), i); 6140 } 6141 if (element.hasGroupIdentifier()) { 6142 composeIdentifier(t, "CommunicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 6143 } 6144 if (element.hasStatusElement()) { 6145 composeEnum(t, "CommunicationRequest", "status", element.getStatusElement(), -1); 6146 } 6147 if (element.hasStatusReason()) { 6148 composeCodeableConcept(t, "CommunicationRequest", "statusReason", element.getStatusReason(), -1); 6149 } 6150 for (int i = 0; i < element.getCategory().size(); i++) { 6151 composeCodeableConcept(t, "CommunicationRequest", "category", element.getCategory().get(i), i); 6152 } 6153 if (element.hasPriorityElement()) { 6154 composeEnum(t, "CommunicationRequest", "priority", element.getPriorityElement(), -1); 6155 } 6156 if (element.hasDoNotPerformElement()) { 6157 composeBoolean(t, "CommunicationRequest", "doNotPerform", element.getDoNotPerformElement(), -1); 6158 } 6159 for (int i = 0; i < element.getMedium().size(); i++) { 6160 composeCodeableConcept(t, "CommunicationRequest", "medium", element.getMedium().get(i), i); 6161 } 6162 if (element.hasSubject()) { 6163 composeReference(t, "CommunicationRequest", "subject", element.getSubject(), -1); 6164 } 6165 for (int i = 0; i < element.getAbout().size(); i++) { 6166 composeReference(t, "CommunicationRequest", "about", element.getAbout().get(i), i); 6167 } 6168 if (element.hasEncounter()) { 6169 composeReference(t, "CommunicationRequest", "encounter", element.getEncounter(), -1); 6170 } 6171 for (int i = 0; i < element.getPayload().size(); i++) { 6172 composeCommunicationRequestPayloadComponent(t, "CommunicationRequest", "payload", element.getPayload().get(i), i); 6173 } 6174 if (element.hasOccurrence()) { 6175 composeType(t, "CommunicationRequest", "occurrence", element.getOccurrence(), -1); 6176 } 6177 if (element.hasAuthoredOnElement()) { 6178 composeDateTime(t, "CommunicationRequest", "authoredOn", element.getAuthoredOnElement(), -1); 6179 } 6180 if (element.hasRequester()) { 6181 composeReference(t, "CommunicationRequest", "requester", element.getRequester(), -1); 6182 } 6183 for (int i = 0; i < element.getRecipient().size(); i++) { 6184 composeReference(t, "CommunicationRequest", "recipient", element.getRecipient().get(i), i); 6185 } 6186 for (int i = 0; i < element.getInformationProvider().size(); i++) { 6187 composeReference(t, "CommunicationRequest", "informationProvider", element.getInformationProvider().get(i), i); 6188 } 6189 for (int i = 0; i < element.getReason().size(); i++) { 6190 composeCodeableReference(t, "CommunicationRequest", "reason", element.getReason().get(i), i); 6191 } 6192 for (int i = 0; i < element.getNote().size(); i++) { 6193 composeAnnotation(t, "CommunicationRequest", "note", element.getNote().get(i), i); 6194 } 6195 } 6196 6197 protected void composeCommunicationRequestPayloadComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestPayloadComponent element, int index) { 6198 if (element == null) 6199 return; 6200 Complex t; 6201 if (Utilities.noString(parentType)) 6202 t = parent; 6203 else { 6204 t = parent.predicate("fhir:"+parentType+'.'+name); 6205 } 6206 composeBackboneElement(t, "payload", name, element, index); 6207 if (element.hasContent()) { 6208 composeType(t, "CommunicationRequestPayloadComponent", "content", element.getContent(), -1); 6209 } 6210 } 6211 6212 protected void composeCompartmentDefinition(Complex parent, String parentType, String name, CompartmentDefinition element, int index) { 6213 if (element == null) 6214 return; 6215 Complex t; 6216 if (Utilities.noString(parentType)) 6217 t = parent; 6218 else { 6219 t = parent.predicate("fhir:"+parentType+'.'+name); 6220 } 6221 composeCanonicalResource(t, "CompartmentDefinition", name, element, index); 6222 if (element.hasUrlElement()) { 6223 composeUri(t, "CompartmentDefinition", "url", element.getUrlElement(), -1); 6224 } 6225 if (element.hasVersionElement()) { 6226 composeString(t, "CompartmentDefinition", "version", element.getVersionElement(), -1); 6227 } 6228 if (element.hasNameElement()) { 6229 composeString(t, "CompartmentDefinition", "name", element.getNameElement(), -1); 6230 } 6231 if (element.hasStatusElement()) { 6232 composeEnum(t, "CompartmentDefinition", "status", element.getStatusElement(), -1); 6233 } 6234 if (element.hasExperimentalElement()) { 6235 composeBoolean(t, "CompartmentDefinition", "experimental", element.getExperimentalElement(), -1); 6236 } 6237 if (element.hasDateElement()) { 6238 composeDateTime(t, "CompartmentDefinition", "date", element.getDateElement(), -1); 6239 } 6240 if (element.hasPublisherElement()) { 6241 composeString(t, "CompartmentDefinition", "publisher", element.getPublisherElement(), -1); 6242 } 6243 for (int i = 0; i < element.getContact().size(); i++) { 6244 composeContactDetail(t, "CompartmentDefinition", "contact", element.getContact().get(i), i); 6245 } 6246 if (element.hasDescriptionElement()) { 6247 composeMarkdown(t, "CompartmentDefinition", "description", element.getDescriptionElement(), -1); 6248 } 6249 for (int i = 0; i < element.getUseContext().size(); i++) { 6250 composeUsageContext(t, "CompartmentDefinition", "useContext", element.getUseContext().get(i), i); 6251 } 6252 if (element.hasPurposeElement()) { 6253 composeMarkdown(t, "CompartmentDefinition", "purpose", element.getPurposeElement(), -1); 6254 } 6255 if (element.hasCodeElement()) { 6256 composeEnum(t, "CompartmentDefinition", "code", element.getCodeElement(), -1); 6257 } 6258 if (element.hasSearchElement()) { 6259 composeBoolean(t, "CompartmentDefinition", "search", element.getSearchElement(), -1); 6260 } 6261 for (int i = 0; i < element.getResource().size(); i++) { 6262 composeCompartmentDefinitionResourceComponent(t, "CompartmentDefinition", "resource", element.getResource().get(i), i); 6263 } 6264 } 6265 6266 protected void composeCompartmentDefinitionResourceComponent(Complex parent, String parentType, String name, CompartmentDefinition.CompartmentDefinitionResourceComponent element, int index) { 6267 if (element == null) 6268 return; 6269 Complex t; 6270 if (Utilities.noString(parentType)) 6271 t = parent; 6272 else { 6273 t = parent.predicate("fhir:"+parentType+'.'+name); 6274 } 6275 composeBackboneElement(t, "resource", name, element, index); 6276 if (element.hasCodeElement()) { 6277 composeCode(t, "CompartmentDefinitionResourceComponent", "code", element.getCodeElement(), -1); 6278 } 6279 for (int i = 0; i < element.getParam().size(); i++) { 6280 composeString(t, "CompartmentDefinitionResourceComponent", "param", element.getParam().get(i), i); 6281 } 6282 if (element.hasDocumentationElement()) { 6283 composeString(t, "CompartmentDefinitionResourceComponent", "documentation", element.getDocumentationElement(), -1); 6284 } 6285 } 6286 6287 protected void composeComposition(Complex parent, String parentType, String name, Composition element, int index) { 6288 if (element == null) 6289 return; 6290 Complex t; 6291 if (Utilities.noString(parentType)) 6292 t = parent; 6293 else { 6294 t = parent.predicate("fhir:"+parentType+'.'+name); 6295 } 6296 composeDomainResource(t, "Composition", name, element, index); 6297 if (element.hasIdentifier()) { 6298 composeIdentifier(t, "Composition", "identifier", element.getIdentifier(), -1); 6299 } 6300 if (element.hasStatusElement()) { 6301 composeEnum(t, "Composition", "status", element.getStatusElement(), -1); 6302 } 6303 if (element.hasType()) { 6304 composeCodeableConcept(t, "Composition", "type", element.getType(), -1); 6305 } 6306 for (int i = 0; i < element.getCategory().size(); i++) { 6307 composeCodeableConcept(t, "Composition", "category", element.getCategory().get(i), i); 6308 } 6309 if (element.hasSubject()) { 6310 composeReference(t, "Composition", "subject", element.getSubject(), -1); 6311 } 6312 if (element.hasEncounter()) { 6313 composeReference(t, "Composition", "encounter", element.getEncounter(), -1); 6314 } 6315 if (element.hasDateElement()) { 6316 composeDateTime(t, "Composition", "date", element.getDateElement(), -1); 6317 } 6318 for (int i = 0; i < element.getAuthor().size(); i++) { 6319 composeReference(t, "Composition", "author", element.getAuthor().get(i), i); 6320 } 6321 if (element.hasTitleElement()) { 6322 composeString(t, "Composition", "title", element.getTitleElement(), -1); 6323 } 6324 if (element.hasConfidentialityElement()) { 6325 composeEnum(t, "Composition", "confidentiality", element.getConfidentialityElement(), -1); 6326 } 6327 for (int i = 0; i < element.getAttester().size(); i++) { 6328 composeCompositionAttesterComponent(t, "Composition", "attester", element.getAttester().get(i), i); 6329 } 6330 if (element.hasCustodian()) { 6331 composeReference(t, "Composition", "custodian", element.getCustodian(), -1); 6332 } 6333 for (int i = 0; i < element.getRelatesTo().size(); i++) { 6334 composeCompositionRelatesToComponent(t, "Composition", "relatesTo", element.getRelatesTo().get(i), i); 6335 } 6336 for (int i = 0; i < element.getEvent().size(); i++) { 6337 composeCompositionEventComponent(t, "Composition", "event", element.getEvent().get(i), i); 6338 } 6339 for (int i = 0; i < element.getSection().size(); i++) { 6340 composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i); 6341 } 6342 } 6343 6344 protected void composeCompositionAttesterComponent(Complex parent, String parentType, String name, Composition.CompositionAttesterComponent element, int index) { 6345 if (element == null) 6346 return; 6347 Complex t; 6348 if (Utilities.noString(parentType)) 6349 t = parent; 6350 else { 6351 t = parent.predicate("fhir:"+parentType+'.'+name); 6352 } 6353 composeBackboneElement(t, "attester", name, element, index); 6354 if (element.hasModeElement()) { 6355 composeEnum(t, "CompositionAttesterComponent", "mode", element.getModeElement(), -1); 6356 } 6357 if (element.hasTimeElement()) { 6358 composeDateTime(t, "CompositionAttesterComponent", "time", element.getTimeElement(), -1); 6359 } 6360 if (element.hasParty()) { 6361 composeReference(t, "CompositionAttesterComponent", "party", element.getParty(), -1); 6362 } 6363 } 6364 6365 protected void composeCompositionRelatesToComponent(Complex parent, String parentType, String name, Composition.CompositionRelatesToComponent element, int index) { 6366 if (element == null) 6367 return; 6368 Complex t; 6369 if (Utilities.noString(parentType)) 6370 t = parent; 6371 else { 6372 t = parent.predicate("fhir:"+parentType+'.'+name); 6373 } 6374 composeBackboneElement(t, "relatesTo", name, element, index); 6375 if (element.hasCodeElement()) { 6376 composeEnum(t, "CompositionRelatesToComponent", "code", element.getCodeElement(), -1); 6377 } 6378 if (element.hasTarget()) { 6379 composeType(t, "CompositionRelatesToComponent", "target", element.getTarget(), -1); 6380 } 6381 } 6382 6383 protected void composeCompositionEventComponent(Complex parent, String parentType, String name, Composition.CompositionEventComponent element, int index) { 6384 if (element == null) 6385 return; 6386 Complex t; 6387 if (Utilities.noString(parentType)) 6388 t = parent; 6389 else { 6390 t = parent.predicate("fhir:"+parentType+'.'+name); 6391 } 6392 composeBackboneElement(t, "event", name, element, index); 6393 for (int i = 0; i < element.getCode().size(); i++) { 6394 composeCodeableConcept(t, "CompositionEventComponent", "code", element.getCode().get(i), i); 6395 } 6396 if (element.hasPeriod()) { 6397 composePeriod(t, "CompositionEventComponent", "period", element.getPeriod(), -1); 6398 } 6399 for (int i = 0; i < element.getDetail().size(); i++) { 6400 composeReference(t, "CompositionEventComponent", "detail", element.getDetail().get(i), i); 6401 } 6402 } 6403 6404 protected void composeCompositionSectionComponent(Complex parent, String parentType, String name, Composition.SectionComponent element, int index) { 6405 if (element == null) 6406 return; 6407 Complex t; 6408 if (Utilities.noString(parentType)) 6409 t = parent; 6410 else { 6411 t = parent.predicate("fhir:"+parentType+'.'+name); 6412 } 6413 composeBackboneElement(t, "section", name, element, index); 6414 if (element.hasTitleElement()) { 6415 composeString(t, "SectionComponent", "title", element.getTitleElement(), -1); 6416 } 6417 if (element.hasCode()) { 6418 composeCodeableConcept(t, "SectionComponent", "code", element.getCode(), -1); 6419 } 6420 for (int i = 0; i < element.getAuthor().size(); i++) { 6421 composeReference(t, "SectionComponent", "author", element.getAuthor().get(i), i); 6422 } 6423 if (element.hasFocus()) { 6424 composeReference(t, "SectionComponent", "focus", element.getFocus(), -1); 6425 } 6426 if (element.hasText()) { 6427 composeNarrative(t, "SectionComponent", "text", element.getText(), -1); 6428 } 6429 if (element.hasModeElement()) { 6430 composeEnum(t, "SectionComponent", "mode", element.getModeElement(), -1); 6431 } 6432 if (element.hasOrderedBy()) { 6433 composeCodeableConcept(t, "SectionComponent", "orderedBy", element.getOrderedBy(), -1); 6434 } 6435 for (int i = 0; i < element.getEntry().size(); i++) { 6436 composeReference(t, "SectionComponent", "entry", element.getEntry().get(i), i); 6437 } 6438 if (element.hasEmptyReason()) { 6439 composeCodeableConcept(t, "SectionComponent", "emptyReason", element.getEmptyReason(), -1); 6440 } 6441 for (int i = 0; i < element.getSection().size(); i++) { 6442 composeCompositionSectionComponent(t, "SectionComponent", "section", element.getSection().get(i), i); 6443 } 6444 } 6445 6446 protected void composeConceptMap(Complex parent, String parentType, String name, ConceptMap element, int index) { 6447 if (element == null) 6448 return; 6449 Complex t; 6450 if (Utilities.noString(parentType)) 6451 t = parent; 6452 else { 6453 t = parent.predicate("fhir:"+parentType+'.'+name); 6454 } 6455 composeCanonicalResource(t, "ConceptMap", name, element, index); 6456 if (element.hasUrlElement()) { 6457 composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1); 6458 } 6459 if (element.hasIdentifier()) { 6460 composeIdentifier(t, "ConceptMap", "identifier", element.getIdentifierFirstRep(), -1); 6461 } 6462 if (element.hasVersionElement()) { 6463 composeString(t, "ConceptMap", "version", element.getVersionElement(), -1); 6464 } 6465 if (element.hasNameElement()) { 6466 composeString(t, "ConceptMap", "name", element.getNameElement(), -1); 6467 } 6468 if (element.hasTitleElement()) { 6469 composeString(t, "ConceptMap", "title", element.getTitleElement(), -1); 6470 } 6471 if (element.hasStatusElement()) { 6472 composeEnum(t, "ConceptMap", "status", element.getStatusElement(), -1); 6473 } 6474 if (element.hasExperimentalElement()) { 6475 composeBoolean(t, "ConceptMap", "experimental", element.getExperimentalElement(), -1); 6476 } 6477 if (element.hasDateElement()) { 6478 composeDateTime(t, "ConceptMap", "date", element.getDateElement(), -1); 6479 } 6480 if (element.hasPublisherElement()) { 6481 composeString(t, "ConceptMap", "publisher", element.getPublisherElement(), -1); 6482 } 6483 for (int i = 0; i < element.getContact().size(); i++) { 6484 composeContactDetail(t, "ConceptMap", "contact", element.getContact().get(i), i); 6485 } 6486 if (element.hasDescriptionElement()) { 6487 composeMarkdown(t, "ConceptMap", "description", element.getDescriptionElement(), -1); 6488 } 6489 for (int i = 0; i < element.getUseContext().size(); i++) { 6490 composeUsageContext(t, "ConceptMap", "useContext", element.getUseContext().get(i), i); 6491 } 6492 for (int i = 0; i < element.getJurisdiction().size(); i++) { 6493 composeCodeableConcept(t, "ConceptMap", "jurisdiction", element.getJurisdiction().get(i), i); 6494 } 6495 if (element.hasPurposeElement()) { 6496 composeMarkdown(t, "ConceptMap", "purpose", element.getPurposeElement(), -1); 6497 } 6498 if (element.hasCopyrightElement()) { 6499 composeMarkdown(t, "ConceptMap", "copyright", element.getCopyrightElement(), -1); 6500 } 6501 if (element.hasSource()) { 6502 composeType(t, "ConceptMap", "source", element.getSource(), -1); 6503 } 6504 if (element.hasTarget()) { 6505 composeType(t, "ConceptMap", "target", element.getTarget(), -1); 6506 } 6507 for (int i = 0; i < element.getGroup().size(); i++) { 6508 composeConceptMapGroupComponent(t, "ConceptMap", "group", element.getGroup().get(i), i); 6509 } 6510 } 6511 6512 protected void composeConceptMapGroupComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupComponent element, int index) { 6513 if (element == null) 6514 return; 6515 Complex t; 6516 if (Utilities.noString(parentType)) 6517 t = parent; 6518 else { 6519 t = parent.predicate("fhir:"+parentType+'.'+name); 6520 } 6521 composeBackboneElement(t, "group", name, element, index); 6522 if (element.hasSourceElement()) { 6523 composeUri(t, "ConceptMapGroupComponent", "source", element.getSourceElement(), -1); 6524 } 6525 if (element.hasSourceVersionElement()) { 6526 composeString(t, "ConceptMapGroupComponent", "sourceVersion", element.getSourceVersionElement(), -1); 6527 } 6528 if (element.hasTargetElement()) { 6529 composeUri(t, "ConceptMapGroupComponent", "target", element.getTargetElement(), -1); 6530 } 6531 if (element.hasTargetVersionElement()) { 6532 composeString(t, "ConceptMapGroupComponent", "targetVersion", element.getTargetVersionElement(), -1); 6533 } 6534 for (int i = 0; i < element.getElement().size(); i++) { 6535 composeConceptMapSourceElementComponent(t, "ConceptMapGroupComponent", "element", element.getElement().get(i), i); 6536 } 6537 if (element.hasUnmapped()) { 6538 composeConceptMapGroupUnmappedComponent(t, "ConceptMapGroupComponent", "unmapped", element.getUnmapped(), -1); 6539 } 6540 } 6541 6542 protected void composeConceptMapSourceElementComponent(Complex parent, String parentType, String name, ConceptMap.SourceElementComponent element, int index) { 6543 if (element == null) 6544 return; 6545 Complex t; 6546 if (Utilities.noString(parentType)) 6547 t = parent; 6548 else { 6549 t = parent.predicate("fhir:"+parentType+'.'+name); 6550 } 6551 composeBackboneElement(t, "element", name, element, index); 6552 if (element.hasCodeElement()) { 6553 composeCode(t, "SourceElementComponent", "code", element.getCodeElement(), -1); 6554 } 6555 if (element.hasDisplayElement()) { 6556 composeString(t, "SourceElementComponent", "display", element.getDisplayElement(), -1); 6557 } 6558 if (element.hasNoMapElement()) { 6559 composeBoolean(t, "SourceElementComponent", "noMap", element.getNoMapElement(), -1); 6560 } 6561 for (int i = 0; i < element.getTarget().size(); i++) { 6562 composeConceptMapTargetElementComponent(t, "SourceElementComponent", "target", element.getTarget().get(i), i); 6563 } 6564 } 6565 6566 protected void composeConceptMapTargetElementComponent(Complex parent, String parentType, String name, ConceptMap.TargetElementComponent element, int index) { 6567 if (element == null) 6568 return; 6569 Complex t; 6570 if (Utilities.noString(parentType)) 6571 t = parent; 6572 else { 6573 t = parent.predicate("fhir:"+parentType+'.'+name); 6574 } 6575 composeBackboneElement(t, "target", name, element, index); 6576 if (element.hasCodeElement()) { 6577 composeCode(t, "TargetElementComponent", "code", element.getCodeElement(), -1); 6578 } 6579 if (element.hasDisplayElement()) { 6580 composeString(t, "TargetElementComponent", "display", element.getDisplayElement(), -1); 6581 } 6582 if (element.hasRelationshipElement()) { 6583 composeEnum(t, "TargetElementComponent", "relationship", element.getRelationshipElement(), -1); 6584 } 6585 if (element.hasCommentElement()) { 6586 composeString(t, "TargetElementComponent", "comment", element.getCommentElement(), -1); 6587 } 6588 for (int i = 0; i < element.getDependsOn().size(); i++) { 6589 composeConceptMapOtherElementComponent(t, "TargetElementComponent", "dependsOn", element.getDependsOn().get(i), i); 6590 } 6591 for (int i = 0; i < element.getProduct().size(); i++) { 6592 composeConceptMapOtherElementComponent(t, "TargetElementComponent", "product", element.getProduct().get(i), i); 6593 } 6594 } 6595 6596 protected void composeConceptMapOtherElementComponent(Complex parent, String parentType, String name, ConceptMap.OtherElementComponent element, int index) { 6597 if (element == null) 6598 return; 6599 Complex t; 6600 if (Utilities.noString(parentType)) 6601 t = parent; 6602 else { 6603 t = parent.predicate("fhir:"+parentType+'.'+name); 6604 } 6605 composeBackboneElement(t, "dependsOn", name, element, index); 6606 if (element.hasPropertyElement()) { 6607 composeUri(t, "OtherElementComponent", "property", element.getPropertyElement(), -1); 6608 } 6609 if (element.hasSystemElement()) { 6610 composeCanonical(t, "OtherElementComponent", "system", element.getSystemElement(), -1); 6611 } 6612 if (element.hasValueElement()) { 6613 composeString(t, "OtherElementComponent", "value", element.getValueElement(), -1); 6614 } 6615 if (element.hasDisplayElement()) { 6616 composeString(t, "OtherElementComponent", "display", element.getDisplayElement(), -1); 6617 } 6618 } 6619 6620 protected void composeConceptMapGroupUnmappedComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupUnmappedComponent element, int index) { 6621 if (element == null) 6622 return; 6623 Complex t; 6624 if (Utilities.noString(parentType)) 6625 t = parent; 6626 else { 6627 t = parent.predicate("fhir:"+parentType+'.'+name); 6628 } 6629 composeBackboneElement(t, "unmapped", name, element, index); 6630 if (element.hasModeElement()) { 6631 composeEnum(t, "ConceptMapGroupUnmappedComponent", "mode", element.getModeElement(), -1); 6632 } 6633 if (element.hasCodeElement()) { 6634 composeCode(t, "ConceptMapGroupUnmappedComponent", "code", element.getCodeElement(), -1); 6635 } 6636 if (element.hasDisplayElement()) { 6637 composeString(t, "ConceptMapGroupUnmappedComponent", "display", element.getDisplayElement(), -1); 6638 } 6639 if (element.hasUrlElement()) { 6640 composeCanonical(t, "ConceptMapGroupUnmappedComponent", "url", element.getUrlElement(), -1); 6641 } 6642 } 6643 6644 protected void composeCondition(Complex parent, String parentType, String name, Condition element, int index) { 6645 if (element == null) 6646 return; 6647 Complex t; 6648 if (Utilities.noString(parentType)) 6649 t = parent; 6650 else { 6651 t = parent.predicate("fhir:"+parentType+'.'+name); 6652 } 6653 composeDomainResource(t, "Condition", name, element, index); 6654 for (int i = 0; i < element.getIdentifier().size(); i++) { 6655 composeIdentifier(t, "Condition", "identifier", element.getIdentifier().get(i), i); 6656 } 6657 if (element.hasClinicalStatus()) { 6658 composeCodeableConcept(t, "Condition", "clinicalStatus", element.getClinicalStatus(), -1); 6659 } 6660 if (element.hasVerificationStatus()) { 6661 composeCodeableConcept(t, "Condition", "verificationStatus", element.getVerificationStatus(), -1); 6662 } 6663 for (int i = 0; i < element.getCategory().size(); i++) { 6664 composeCodeableConcept(t, "Condition", "category", element.getCategory().get(i), i); 6665 } 6666 if (element.hasSeverity()) { 6667 composeCodeableConcept(t, "Condition", "severity", element.getSeverity(), -1); 6668 } 6669 if (element.hasCode()) { 6670 composeCodeableConcept(t, "Condition", "code", element.getCode(), -1); 6671 } 6672 for (int i = 0; i < element.getBodySite().size(); i++) { 6673 composeCodeableConcept(t, "Condition", "bodySite", element.getBodySite().get(i), i); 6674 } 6675 if (element.hasSubject()) { 6676 composeReference(t, "Condition", "subject", element.getSubject(), -1); 6677 } 6678 if (element.hasEncounter()) { 6679 composeReference(t, "Condition", "encounter", element.getEncounter(), -1); 6680 } 6681 if (element.hasOnset()) { 6682 composeType(t, "Condition", "onset", element.getOnset(), -1); 6683 } 6684 if (element.hasAbatement()) { 6685 composeType(t, "Condition", "abatement", element.getAbatement(), -1); 6686 } 6687 if (element.hasRecordedDateElement()) { 6688 composeDateTime(t, "Condition", "recordedDate", element.getRecordedDateElement(), -1); 6689 } 6690 if (element.hasRecorder()) { 6691 composeReference(t, "Condition", "recorder", element.getRecorder(), -1); 6692 } 6693 if (element.hasAsserter()) { 6694 composeReference(t, "Condition", "asserter", element.getAsserter(), -1); 6695 } 6696 for (int i = 0; i < element.getStage().size(); i++) { 6697 composeConditionStageComponent(t, "Condition", "stage", element.getStage().get(i), i); 6698 } 6699 for (int i = 0; i < element.getEvidence().size(); i++) { 6700 composeConditionEvidenceComponent(t, "Condition", "evidence", element.getEvidence().get(i), i); 6701 } 6702 for (int i = 0; i < element.getNote().size(); i++) { 6703 composeAnnotation(t, "Condition", "note", element.getNote().get(i), i); 6704 } 6705 } 6706 6707 protected void composeConditionStageComponent(Complex parent, String parentType, String name, Condition.ConditionStageComponent element, int index) { 6708 if (element == null) 6709 return; 6710 Complex t; 6711 if (Utilities.noString(parentType)) 6712 t = parent; 6713 else { 6714 t = parent.predicate("fhir:"+parentType+'.'+name); 6715 } 6716 composeBackboneElement(t, "stage", name, element, index); 6717 if (element.hasSummary()) { 6718 composeCodeableConcept(t, "ConditionStageComponent", "summary", element.getSummary(), -1); 6719 } 6720 for (int i = 0; i < element.getAssessment().size(); i++) { 6721 composeReference(t, "ConditionStageComponent", "assessment", element.getAssessment().get(i), i); 6722 } 6723 if (element.hasType()) { 6724 composeCodeableConcept(t, "ConditionStageComponent", "type", element.getType(), -1); 6725 } 6726 } 6727 6728 protected void composeConditionEvidenceComponent(Complex parent, String parentType, String name, Condition.ConditionEvidenceComponent element, int index) { 6729 if (element == null) 6730 return; 6731 Complex t; 6732 if (Utilities.noString(parentType)) 6733 t = parent; 6734 else { 6735 t = parent.predicate("fhir:"+parentType+'.'+name); 6736 } 6737 composeBackboneElement(t, "evidence", name, element, index); 6738 for (int i = 0; i < element.getCode().size(); i++) { 6739 composeCodeableConcept(t, "ConditionEvidenceComponent", "code", element.getCode().get(i), i); 6740 } 6741 for (int i = 0; i < element.getDetail().size(); i++) { 6742 composeReference(t, "ConditionEvidenceComponent", "detail", element.getDetail().get(i), i); 6743 } 6744 } 6745 6746 protected void composeConditionDefinition(Complex parent, String parentType, String name, ConditionDefinition element, int index) { 6747 if (element == null) 6748 return; 6749 Complex t; 6750 if (Utilities.noString(parentType)) 6751 t = parent; 6752 else { 6753 t = parent.predicate("fhir:"+parentType+'.'+name); 6754 } 6755 composeMetadataResource(t, "ConditionDefinition", name, element, index); 6756 if (element.hasUrlElement()) { 6757 composeUri(t, "ConditionDefinition", "url", element.getUrlElement(), -1); 6758 } 6759 for (int i = 0; i < element.getIdentifier().size(); i++) { 6760 composeIdentifier(t, "ConditionDefinition", "identifier", element.getIdentifier().get(i), i); 6761 } 6762 if (element.hasVersionElement()) { 6763 composeString(t, "ConditionDefinition", "version", element.getVersionElement(), -1); 6764 } 6765 if (element.hasNameElement()) { 6766 composeString(t, "ConditionDefinition", "name", element.getNameElement(), -1); 6767 } 6768 if (element.hasTitleElement()) { 6769 composeString(t, "ConditionDefinition", "title", element.getTitleElement(), -1); 6770 } 6771 if (element.hasSubtitleElement()) { 6772 composeString(t, "ConditionDefinition", "subtitle", element.getSubtitleElement(), -1); 6773 } 6774 if (element.hasStatusElement()) { 6775 composeEnum(t, "ConditionDefinition", "status", element.getStatusElement(), -1); 6776 } 6777 if (element.hasExperimentalElement()) { 6778 composeBoolean(t, "ConditionDefinition", "experimental", element.getExperimentalElement(), -1); 6779 } 6780 if (element.hasDateElement()) { 6781 composeDateTime(t, "ConditionDefinition", "date", element.getDateElement(), -1); 6782 } 6783 if (element.hasPublisherElement()) { 6784 composeString(t, "ConditionDefinition", "publisher", element.getPublisherElement(), -1); 6785 } 6786 for (int i = 0; i < element.getContact().size(); i++) { 6787 composeContactDetail(t, "ConditionDefinition", "contact", element.getContact().get(i), i); 6788 } 6789 if (element.hasDescriptionElement()) { 6790 composeMarkdown(t, "ConditionDefinition", "description", element.getDescriptionElement(), -1); 6791 } 6792 for (int i = 0; i < element.getUseContext().size(); i++) { 6793 composeUsageContext(t, "ConditionDefinition", "useContext", element.getUseContext().get(i), i); 6794 } 6795 for (int i = 0; i < element.getJurisdiction().size(); i++) { 6796 composeCodeableConcept(t, "ConditionDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 6797 } 6798 if (element.hasCode()) { 6799 composeCodeableConcept(t, "ConditionDefinition", "code", element.getCode(), -1); 6800 } 6801 if (element.hasSeverity()) { 6802 composeCodeableConcept(t, "ConditionDefinition", "severity", element.getSeverity(), -1); 6803 } 6804 if (element.hasBodySite()) { 6805 composeCodeableConcept(t, "ConditionDefinition", "bodySite", element.getBodySite(), -1); 6806 } 6807 if (element.hasStage()) { 6808 composeCodeableConcept(t, "ConditionDefinition", "stage", element.getStage(), -1); 6809 } 6810 if (element.hasHasSeverityElement()) { 6811 composeBoolean(t, "ConditionDefinition", "hasSeverity", element.getHasSeverityElement(), -1); 6812 } 6813 if (element.hasHasBodySiteElement()) { 6814 composeBoolean(t, "ConditionDefinition", "hasBodySite", element.getHasBodySiteElement(), -1); 6815 } 6816 if (element.hasHasStageElement()) { 6817 composeBoolean(t, "ConditionDefinition", "hasStage", element.getHasStageElement(), -1); 6818 } 6819 for (int i = 0; i < element.getDefinition().size(); i++) { 6820 composeUri(t, "ConditionDefinition", "definition", element.getDefinition().get(i), i); 6821 } 6822 for (int i = 0; i < element.getObservation().size(); i++) { 6823 composeConditionDefinitionObservationComponent(t, "ConditionDefinition", "observation", element.getObservation().get(i), i); 6824 } 6825 for (int i = 0; i < element.getMedication().size(); i++) { 6826 composeConditionDefinitionMedicationComponent(t, "ConditionDefinition", "medication", element.getMedication().get(i), i); 6827 } 6828 for (int i = 0; i < element.getPrecondition().size(); i++) { 6829 composeConditionDefinitionPreconditionComponent(t, "ConditionDefinition", "precondition", element.getPrecondition().get(i), i); 6830 } 6831 for (int i = 0; i < element.getTeam().size(); i++) { 6832 composeReference(t, "ConditionDefinition", "team", element.getTeam().get(i), i); 6833 } 6834 for (int i = 0; i < element.getQuestionnaire().size(); i++) { 6835 composeConditionDefinitionQuestionnaireComponent(t, "ConditionDefinition", "questionnaire", element.getQuestionnaire().get(i), i); 6836 } 6837 for (int i = 0; i < element.getPlan().size(); i++) { 6838 composeConditionDefinitionPlanComponent(t, "ConditionDefinition", "plan", element.getPlan().get(i), i); 6839 } 6840 } 6841 6842 protected void composeConditionDefinitionObservationComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionObservationComponent element, int index) { 6843 if (element == null) 6844 return; 6845 Complex t; 6846 if (Utilities.noString(parentType)) 6847 t = parent; 6848 else { 6849 t = parent.predicate("fhir:"+parentType+'.'+name); 6850 } 6851 composeBackboneElement(t, "observation", name, element, index); 6852 if (element.hasCategory()) { 6853 composeCodeableConcept(t, "ConditionDefinitionObservationComponent", "category", element.getCategory(), -1); 6854 } 6855 if (element.hasCode()) { 6856 composeCodeableConcept(t, "ConditionDefinitionObservationComponent", "code", element.getCode(), -1); 6857 } 6858 } 6859 6860 protected void composeConditionDefinitionMedicationComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionMedicationComponent element, int index) { 6861 if (element == null) 6862 return; 6863 Complex t; 6864 if (Utilities.noString(parentType)) 6865 t = parent; 6866 else { 6867 t = parent.predicate("fhir:"+parentType+'.'+name); 6868 } 6869 composeBackboneElement(t, "medication", name, element, index); 6870 if (element.hasCategory()) { 6871 composeCodeableConcept(t, "ConditionDefinitionMedicationComponent", "category", element.getCategory(), -1); 6872 } 6873 if (element.hasCode()) { 6874 composeCodeableConcept(t, "ConditionDefinitionMedicationComponent", "code", element.getCode(), -1); 6875 } 6876 } 6877 6878 protected void composeConditionDefinitionPreconditionComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionPreconditionComponent element, int index) { 6879 if (element == null) 6880 return; 6881 Complex t; 6882 if (Utilities.noString(parentType)) 6883 t = parent; 6884 else { 6885 t = parent.predicate("fhir:"+parentType+'.'+name); 6886 } 6887 composeBackboneElement(t, "precondition", name, element, index); 6888 if (element.hasTypeElement()) { 6889 composeEnum(t, "ConditionDefinitionPreconditionComponent", "type", element.getTypeElement(), -1); 6890 } 6891 if (element.hasCode()) { 6892 composeCodeableConcept(t, "ConditionDefinitionPreconditionComponent", "code", element.getCode(), -1); 6893 } 6894 if (element.hasValue()) { 6895 composeType(t, "ConditionDefinitionPreconditionComponent", "value", element.getValue(), -1); 6896 } 6897 } 6898 6899 protected void composeConditionDefinitionQuestionnaireComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionQuestionnaireComponent element, int index) { 6900 if (element == null) 6901 return; 6902 Complex t; 6903 if (Utilities.noString(parentType)) 6904 t = parent; 6905 else { 6906 t = parent.predicate("fhir:"+parentType+'.'+name); 6907 } 6908 composeBackboneElement(t, "questionnaire", name, element, index); 6909 if (element.hasPurposeElement()) { 6910 composeEnum(t, "ConditionDefinitionQuestionnaireComponent", "purpose", element.getPurposeElement(), -1); 6911 } 6912 if (element.hasReference()) { 6913 composeReference(t, "ConditionDefinitionQuestionnaireComponent", "reference", element.getReference(), -1); 6914 } 6915 } 6916 6917 protected void composeConditionDefinitionPlanComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionPlanComponent element, int index) { 6918 if (element == null) 6919 return; 6920 Complex t; 6921 if (Utilities.noString(parentType)) 6922 t = parent; 6923 else { 6924 t = parent.predicate("fhir:"+parentType+'.'+name); 6925 } 6926 composeBackboneElement(t, "plan", name, element, index); 6927 if (element.hasRole()) { 6928 composeCodeableConcept(t, "ConditionDefinitionPlanComponent", "role", element.getRole(), -1); 6929 } 6930 if (element.hasReference()) { 6931 composeReference(t, "ConditionDefinitionPlanComponent", "reference", element.getReference(), -1); 6932 } 6933 } 6934 6935 protected void composeConsent(Complex parent, String parentType, String name, Consent element, int index) { 6936 if (element == null) 6937 return; 6938 Complex t; 6939 if (Utilities.noString(parentType)) 6940 t = parent; 6941 else { 6942 t = parent.predicate("fhir:"+parentType+'.'+name); 6943 } 6944 composeDomainResource(t, "Consent", name, element, index); 6945 for (int i = 0; i < element.getIdentifier().size(); i++) { 6946 composeIdentifier(t, "Consent", "identifier", element.getIdentifier().get(i), i); 6947 } 6948 if (element.hasStatusElement()) { 6949 composeEnum(t, "Consent", "status", element.getStatusElement(), -1); 6950 } 6951 if (element.hasScope()) { 6952 composeCodeableConcept(t, "Consent", "scope", element.getScope(), -1); 6953 } 6954 for (int i = 0; i < element.getCategory().size(); i++) { 6955 composeCodeableConcept(t, "Consent", "category", element.getCategory().get(i), i); 6956 } 6957 if (element.hasPatient()) { 6958 composeReference(t, "Consent", "patient", element.getPatient(), -1); 6959 } 6960 if (element.hasDateTimeElement()) { 6961 composeDateTime(t, "Consent", "dateTime", element.getDateTimeElement(), -1); 6962 } 6963 for (int i = 0; i < element.getPerformer().size(); i++) { 6964 composeReference(t, "Consent", "performer", element.getPerformer().get(i), i); 6965 } 6966 for (int i = 0; i < element.getOrganization().size(); i++) { 6967 composeReference(t, "Consent", "organization", element.getOrganization().get(i), i); 6968 } 6969 for (int i = 0; i < element.getSourceAttachment().size(); i++) { 6970 composeAttachment(t, "Consent", "sourceAttachment", element.getSourceAttachment().get(i), i); 6971 } 6972 for (int i = 0; i < element.getSourceReference().size(); i++) { 6973 composeReference(t, "Consent", "sourceReference", element.getSourceReference().get(i), i); 6974 } 6975 for (int i = 0; i < element.getPolicy().size(); i++) { 6976 composeConsentPolicyComponent(t, "Consent", "policy", element.getPolicy().get(i), i); 6977 } 6978 if (element.hasPolicyRule()) { 6979 composeCodeableConcept(t, "Consent", "policyRule", element.getPolicyRule(), -1); 6980 } 6981 for (int i = 0; i < element.getVerification().size(); i++) { 6982 composeConsentVerificationComponent(t, "Consent", "verification", element.getVerification().get(i), i); 6983 } 6984 if (element.hasProvision()) { 6985 composeConsentProvisionComponent(t, "Consent", "provision", element.getProvision(), -1); 6986 } 6987 } 6988 6989 protected void composeConsentPolicyComponent(Complex parent, String parentType, String name, Consent.ConsentPolicyComponent element, int index) { 6990 if (element == null) 6991 return; 6992 Complex t; 6993 if (Utilities.noString(parentType)) 6994 t = parent; 6995 else { 6996 t = parent.predicate("fhir:"+parentType+'.'+name); 6997 } 6998 composeBackboneElement(t, "policy", name, element, index); 6999 if (element.hasAuthorityElement()) { 7000 composeUri(t, "ConsentPolicyComponent", "authority", element.getAuthorityElement(), -1); 7001 } 7002 if (element.hasUriElement()) { 7003 composeUri(t, "ConsentPolicyComponent", "uri", element.getUriElement(), -1); 7004 } 7005 } 7006 7007 protected void composeConsentVerificationComponent(Complex parent, String parentType, String name, Consent.ConsentVerificationComponent element, int index) { 7008 if (element == null) 7009 return; 7010 Complex t; 7011 if (Utilities.noString(parentType)) 7012 t = parent; 7013 else { 7014 t = parent.predicate("fhir:"+parentType+'.'+name); 7015 } 7016 composeBackboneElement(t, "verification", name, element, index); 7017 if (element.hasVerifiedElement()) { 7018 composeBoolean(t, "ConsentVerificationComponent", "verified", element.getVerifiedElement(), -1); 7019 } 7020 if (element.hasVerificationType()) { 7021 composeCodeableConcept(t, "ConsentVerificationComponent", "verificationType", element.getVerificationType(), -1); 7022 } 7023 if (element.hasVerifiedBy()) { 7024 composeReference(t, "ConsentVerificationComponent", "verifiedBy", element.getVerifiedBy(), -1); 7025 } 7026 if (element.hasVerifiedWith()) { 7027 composeReference(t, "ConsentVerificationComponent", "verifiedWith", element.getVerifiedWith(), -1); 7028 } 7029 for (int i = 0; i < element.getVerificationDate().size(); i++) { 7030 composeDateTime(t, "ConsentVerificationComponent", "verificationDate", element.getVerificationDate().get(i), i); 7031 } 7032 } 7033 7034 protected void composeConsentProvisionComponent(Complex parent, String parentType, String name, Consent.ProvisionComponent element, int index) { 7035 if (element == null) 7036 return; 7037 Complex t; 7038 if (Utilities.noString(parentType)) 7039 t = parent; 7040 else { 7041 t = parent.predicate("fhir:"+parentType+'.'+name); 7042 } 7043 composeBackboneElement(t, "provision", name, element, index); 7044 if (element.hasTypeElement()) { 7045 composeEnum(t, "ProvisionComponent", "type", element.getTypeElement(), -1); 7046 } 7047 if (element.hasPeriod()) { 7048 composePeriod(t, "ProvisionComponent", "period", element.getPeriod(), -1); 7049 } 7050 for (int i = 0; i < element.getActor().size(); i++) { 7051 composeConsentProvisionActorComponent(t, "ProvisionComponent", "actor", element.getActor().get(i), i); 7052 } 7053 for (int i = 0; i < element.getAction().size(); i++) { 7054 composeCodeableConcept(t, "ProvisionComponent", "action", element.getAction().get(i), i); 7055 } 7056 for (int i = 0; i < element.getSecurityLabel().size(); i++) { 7057 composeCoding(t, "ProvisionComponent", "securityLabel", element.getSecurityLabel().get(i), i); 7058 } 7059 for (int i = 0; i < element.getPurpose().size(); i++) { 7060 composeCoding(t, "ProvisionComponent", "purpose", element.getPurpose().get(i), i); 7061 } 7062 for (int i = 0; i < element.getClass_().size(); i++) { 7063 composeCoding(t, "ProvisionComponent", "class", element.getClass_().get(i), i); 7064 } 7065 for (int i = 0; i < element.getCode().size(); i++) { 7066 composeCodeableConcept(t, "ProvisionComponent", "code", element.getCode().get(i), i); 7067 } 7068 if (element.hasDataPeriod()) { 7069 composePeriod(t, "ProvisionComponent", "dataPeriod", element.getDataPeriod(), -1); 7070 } 7071 for (int i = 0; i < element.getData().size(); i++) { 7072 composeConsentProvisionDataComponent(t, "ProvisionComponent", "data", element.getData().get(i), i); 7073 } 7074 for (int i = 0; i < element.getProvision().size(); i++) { 7075 composeConsentProvisionComponent(t, "ProvisionComponent", "provision", element.getProvision().get(i), i); 7076 } 7077 } 7078 7079 protected void composeConsentProvisionActorComponent(Complex parent, String parentType, String name, Consent.ProvisionActorComponent element, int index) { 7080 if (element == null) 7081 return; 7082 Complex t; 7083 if (Utilities.noString(parentType)) 7084 t = parent; 7085 else { 7086 t = parent.predicate("fhir:"+parentType+'.'+name); 7087 } 7088 composeBackboneElement(t, "actor", name, element, index); 7089 if (element.hasRole()) { 7090 composeCodeableConcept(t, "ProvisionActorComponent", "role", element.getRole(), -1); 7091 } 7092 if (element.hasReference()) { 7093 composeReference(t, "ProvisionActorComponent", "reference", element.getReference(), -1); 7094 } 7095 } 7096 7097 protected void composeConsentProvisionDataComponent(Complex parent, String parentType, String name, Consent.ProvisionDataComponent element, int index) { 7098 if (element == null) 7099 return; 7100 Complex t; 7101 if (Utilities.noString(parentType)) 7102 t = parent; 7103 else { 7104 t = parent.predicate("fhir:"+parentType+'.'+name); 7105 } 7106 composeBackboneElement(t, "data", name, element, index); 7107 if (element.hasMeaningElement()) { 7108 composeEnum(t, "ProvisionDataComponent", "meaning", element.getMeaningElement(), -1); 7109 } 7110 if (element.hasReference()) { 7111 composeReference(t, "ProvisionDataComponent", "reference", element.getReference(), -1); 7112 } 7113 } 7114 7115 protected void composeContract(Complex parent, String parentType, String name, Contract element, int index) { 7116 if (element == null) 7117 return; 7118 Complex t; 7119 if (Utilities.noString(parentType)) 7120 t = parent; 7121 else { 7122 t = parent.predicate("fhir:"+parentType+'.'+name); 7123 } 7124 composeDomainResource(t, "Contract", name, element, index); 7125 for (int i = 0; i < element.getIdentifier().size(); i++) { 7126 composeIdentifier(t, "Contract", "identifier", element.getIdentifier().get(i), i); 7127 } 7128 if (element.hasUrlElement()) { 7129 composeUri(t, "Contract", "url", element.getUrlElement(), -1); 7130 } 7131 if (element.hasVersionElement()) { 7132 composeString(t, "Contract", "version", element.getVersionElement(), -1); 7133 } 7134 if (element.hasStatusElement()) { 7135 composeEnum(t, "Contract", "status", element.getStatusElement(), -1); 7136 } 7137 if (element.hasLegalState()) { 7138 composeCodeableConcept(t, "Contract", "legalState", element.getLegalState(), -1); 7139 } 7140 if (element.hasInstantiatesCanonical()) { 7141 composeReference(t, "Contract", "instantiatesCanonical", element.getInstantiatesCanonical(), -1); 7142 } 7143 if (element.hasInstantiatesUriElement()) { 7144 composeUri(t, "Contract", "instantiatesUri", element.getInstantiatesUriElement(), -1); 7145 } 7146 if (element.hasContentDerivative()) { 7147 composeCodeableConcept(t, "Contract", "contentDerivative", element.getContentDerivative(), -1); 7148 } 7149 if (element.hasIssuedElement()) { 7150 composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1); 7151 } 7152 if (element.hasApplies()) { 7153 composePeriod(t, "Contract", "applies", element.getApplies(), -1); 7154 } 7155 if (element.hasExpirationType()) { 7156 composeCodeableConcept(t, "Contract", "expirationType", element.getExpirationType(), -1); 7157 } 7158 for (int i = 0; i < element.getSubject().size(); i++) { 7159 composeReference(t, "Contract", "subject", element.getSubject().get(i), i); 7160 } 7161 for (int i = 0; i < element.getAuthority().size(); i++) { 7162 composeReference(t, "Contract", "authority", element.getAuthority().get(i), i); 7163 } 7164 for (int i = 0; i < element.getDomain().size(); i++) { 7165 composeReference(t, "Contract", "domain", element.getDomain().get(i), i); 7166 } 7167 for (int i = 0; i < element.getSite().size(); i++) { 7168 composeReference(t, "Contract", "site", element.getSite().get(i), i); 7169 } 7170 if (element.hasNameElement()) { 7171 composeString(t, "Contract", "name", element.getNameElement(), -1); 7172 } 7173 if (element.hasTitleElement()) { 7174 composeString(t, "Contract", "title", element.getTitleElement(), -1); 7175 } 7176 if (element.hasSubtitleElement()) { 7177 composeString(t, "Contract", "subtitle", element.getSubtitleElement(), -1); 7178 } 7179 for (int i = 0; i < element.getAlias().size(); i++) { 7180 composeString(t, "Contract", "alias", element.getAlias().get(i), i); 7181 } 7182 if (element.hasAuthor()) { 7183 composeReference(t, "Contract", "author", element.getAuthor(), -1); 7184 } 7185 if (element.hasScope()) { 7186 composeCodeableConcept(t, "Contract", "scope", element.getScope(), -1); 7187 } 7188 if (element.hasTopic()) { 7189 composeType(t, "Contract", "topic", element.getTopic(), -1); 7190 } 7191 if (element.hasType()) { 7192 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 7193 } 7194 for (int i = 0; i < element.getSubType().size(); i++) { 7195 composeCodeableConcept(t, "Contract", "subType", element.getSubType().get(i), i); 7196 } 7197 if (element.hasContentDefinition()) { 7198 composeContractContentDefinitionComponent(t, "Contract", "contentDefinition", element.getContentDefinition(), -1); 7199 } 7200 for (int i = 0; i < element.getTerm().size(); i++) { 7201 composeContractTermComponent(t, "Contract", "term", element.getTerm().get(i), i); 7202 } 7203 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 7204 composeReference(t, "Contract", "supportingInfo", element.getSupportingInfo().get(i), i); 7205 } 7206 for (int i = 0; i < element.getRelevantHistory().size(); i++) { 7207 composeReference(t, "Contract", "relevantHistory", element.getRelevantHistory().get(i), i); 7208 } 7209 for (int i = 0; i < element.getSigner().size(); i++) { 7210 composeContractSignatoryComponent(t, "Contract", "signer", element.getSigner().get(i), i); 7211 } 7212 for (int i = 0; i < element.getFriendly().size(); i++) { 7213 composeContractFriendlyLanguageComponent(t, "Contract", "friendly", element.getFriendly().get(i), i); 7214 } 7215 for (int i = 0; i < element.getLegal().size(); i++) { 7216 composeContractLegalLanguageComponent(t, "Contract", "legal", element.getLegal().get(i), i); 7217 } 7218 for (int i = 0; i < element.getRule().size(); i++) { 7219 composeContractComputableLanguageComponent(t, "Contract", "rule", element.getRule().get(i), i); 7220 } 7221 if (element.hasLegallyBinding()) { 7222 composeType(t, "Contract", "legallyBinding", element.getLegallyBinding(), -1); 7223 } 7224 } 7225 7226 protected void composeContractContentDefinitionComponent(Complex parent, String parentType, String name, Contract.ContentDefinitionComponent 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, "contentDefinition", name, element, index); 7236 if (element.hasType()) { 7237 composeCodeableConcept(t, "ContentDefinitionComponent", "type", element.getType(), -1); 7238 } 7239 if (element.hasSubType()) { 7240 composeCodeableConcept(t, "ContentDefinitionComponent", "subType", element.getSubType(), -1); 7241 } 7242 if (element.hasPublisher()) { 7243 composeReference(t, "ContentDefinitionComponent", "publisher", element.getPublisher(), -1); 7244 } 7245 if (element.hasPublicationDateElement()) { 7246 composeDateTime(t, "ContentDefinitionComponent", "publicationDate", element.getPublicationDateElement(), -1); 7247 } 7248 if (element.hasPublicationStatusElement()) { 7249 composeEnum(t, "ContentDefinitionComponent", "publicationStatus", element.getPublicationStatusElement(), -1); 7250 } 7251 if (element.hasCopyrightElement()) { 7252 composeMarkdown(t, "ContentDefinitionComponent", "copyright", element.getCopyrightElement(), -1); 7253 } 7254 } 7255 7256 protected void composeContractTermComponent(Complex parent, String parentType, String name, Contract.TermComponent element, int index) { 7257 if (element == null) 7258 return; 7259 Complex t; 7260 if (Utilities.noString(parentType)) 7261 t = parent; 7262 else { 7263 t = parent.predicate("fhir:"+parentType+'.'+name); 7264 } 7265 composeBackboneElement(t, "term", name, element, index); 7266 if (element.hasIdentifier()) { 7267 composeIdentifier(t, "TermComponent", "identifier", element.getIdentifier(), -1); 7268 } 7269 if (element.hasIssuedElement()) { 7270 composeDateTime(t, "TermComponent", "issued", element.getIssuedElement(), -1); 7271 } 7272 if (element.hasApplies()) { 7273 composePeriod(t, "TermComponent", "applies", element.getApplies(), -1); 7274 } 7275 if (element.hasTopic()) { 7276 composeType(t, "TermComponent", "topic", element.getTopic(), -1); 7277 } 7278 if (element.hasType()) { 7279 composeCodeableConcept(t, "TermComponent", "type", element.getType(), -1); 7280 } 7281 if (element.hasSubType()) { 7282 composeCodeableConcept(t, "TermComponent", "subType", element.getSubType(), -1); 7283 } 7284 if (element.hasTextElement()) { 7285 composeString(t, "TermComponent", "text", element.getTextElement(), -1); 7286 } 7287 for (int i = 0; i < element.getSecurityLabel().size(); i++) { 7288 composeContractSecurityLabelComponent(t, "TermComponent", "securityLabel", element.getSecurityLabel().get(i), i); 7289 } 7290 if (element.hasOffer()) { 7291 composeContractOfferComponent(t, "TermComponent", "offer", element.getOffer(), -1); 7292 } 7293 for (int i = 0; i < element.getAsset().size(); i++) { 7294 composeContractAssetComponent(t, "TermComponent", "asset", element.getAsset().get(i), i); 7295 } 7296 for (int i = 0; i < element.getAction().size(); i++) { 7297 composeContractActionComponent(t, "TermComponent", "action", element.getAction().get(i), i); 7298 } 7299 for (int i = 0; i < element.getGroup().size(); i++) { 7300 composeContractTermComponent(t, "TermComponent", "group", element.getGroup().get(i), i); 7301 } 7302 } 7303 7304 protected void composeContractSecurityLabelComponent(Complex parent, String parentType, String name, Contract.SecurityLabelComponent element, int index) { 7305 if (element == null) 7306 return; 7307 Complex t; 7308 if (Utilities.noString(parentType)) 7309 t = parent; 7310 else { 7311 t = parent.predicate("fhir:"+parentType+'.'+name); 7312 } 7313 composeBackboneElement(t, "securityLabel", name, element, index); 7314 for (int i = 0; i < element.getNumber().size(); i++) { 7315 composeUnsignedInt(t, "SecurityLabelComponent", "number", element.getNumber().get(i), i); 7316 } 7317 if (element.hasClassification()) { 7318 composeCoding(t, "SecurityLabelComponent", "classification", element.getClassification(), -1); 7319 } 7320 for (int i = 0; i < element.getCategory().size(); i++) { 7321 composeCoding(t, "SecurityLabelComponent", "category", element.getCategory().get(i), i); 7322 } 7323 for (int i = 0; i < element.getControl().size(); i++) { 7324 composeCoding(t, "SecurityLabelComponent", "control", element.getControl().get(i), i); 7325 } 7326 } 7327 7328 protected void composeContractOfferComponent(Complex parent, String parentType, String name, Contract.ContractOfferComponent element, int index) { 7329 if (element == null) 7330 return; 7331 Complex t; 7332 if (Utilities.noString(parentType)) 7333 t = parent; 7334 else { 7335 t = parent.predicate("fhir:"+parentType+'.'+name); 7336 } 7337 composeBackboneElement(t, "offer", name, element, index); 7338 for (int i = 0; i < element.getIdentifier().size(); i++) { 7339 composeIdentifier(t, "ContractOfferComponent", "identifier", element.getIdentifier().get(i), i); 7340 } 7341 for (int i = 0; i < element.getParty().size(); i++) { 7342 composeContractPartyComponent(t, "ContractOfferComponent", "party", element.getParty().get(i), i); 7343 } 7344 if (element.hasTopic()) { 7345 composeReference(t, "ContractOfferComponent", "topic", element.getTopic(), -1); 7346 } 7347 if (element.hasType()) { 7348 composeCodeableConcept(t, "ContractOfferComponent", "type", element.getType(), -1); 7349 } 7350 if (element.hasDecision()) { 7351 composeCodeableConcept(t, "ContractOfferComponent", "decision", element.getDecision(), -1); 7352 } 7353 for (int i = 0; i < element.getDecisionMode().size(); i++) { 7354 composeCodeableConcept(t, "ContractOfferComponent", "decisionMode", element.getDecisionMode().get(i), i); 7355 } 7356 for (int i = 0; i < element.getAnswer().size(); i++) { 7357 composeContractAnswerComponent(t, "ContractOfferComponent", "answer", element.getAnswer().get(i), i); 7358 } 7359 if (element.hasTextElement()) { 7360 composeString(t, "ContractOfferComponent", "text", element.getTextElement(), -1); 7361 } 7362 for (int i = 0; i < element.getLinkId().size(); i++) { 7363 composeString(t, "ContractOfferComponent", "linkId", element.getLinkId().get(i), i); 7364 } 7365 for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) { 7366 composeUnsignedInt(t, "ContractOfferComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i); 7367 } 7368 } 7369 7370 protected void composeContractPartyComponent(Complex parent, String parentType, String name, Contract.ContractPartyComponent element, int index) { 7371 if (element == null) 7372 return; 7373 Complex t; 7374 if (Utilities.noString(parentType)) 7375 t = parent; 7376 else { 7377 t = parent.predicate("fhir:"+parentType+'.'+name); 7378 } 7379 composeBackboneElement(t, "party", name, element, index); 7380 for (int i = 0; i < element.getReference().size(); i++) { 7381 composeReference(t, "ContractPartyComponent", "reference", element.getReference().get(i), i); 7382 } 7383 if (element.hasRole()) { 7384 composeCodeableConcept(t, "ContractPartyComponent", "role", element.getRole(), -1); 7385 } 7386 } 7387 7388 protected void composeContractAnswerComponent(Complex parent, String parentType, String name, Contract.AnswerComponent element, int index) { 7389 if (element == null) 7390 return; 7391 Complex t; 7392 if (Utilities.noString(parentType)) 7393 t = parent; 7394 else { 7395 t = parent.predicate("fhir:"+parentType+'.'+name); 7396 } 7397 composeBackboneElement(t, "answer", name, element, index); 7398 if (element.hasValue()) { 7399 composeType(t, "AnswerComponent", "value", element.getValue(), -1); 7400 } 7401 } 7402 7403 protected void composeContractAssetComponent(Complex parent, String parentType, String name, Contract.ContractAssetComponent element, int index) { 7404 if (element == null) 7405 return; 7406 Complex t; 7407 if (Utilities.noString(parentType)) 7408 t = parent; 7409 else { 7410 t = parent.predicate("fhir:"+parentType+'.'+name); 7411 } 7412 composeBackboneElement(t, "asset", name, element, index); 7413 if (element.hasScope()) { 7414 composeCodeableConcept(t, "ContractAssetComponent", "scope", element.getScope(), -1); 7415 } 7416 for (int i = 0; i < element.getType().size(); i++) { 7417 composeCodeableConcept(t, "ContractAssetComponent", "type", element.getType().get(i), i); 7418 } 7419 for (int i = 0; i < element.getTypeReference().size(); i++) { 7420 composeReference(t, "ContractAssetComponent", "typeReference", element.getTypeReference().get(i), i); 7421 } 7422 for (int i = 0; i < element.getSubtype().size(); i++) { 7423 composeCodeableConcept(t, "ContractAssetComponent", "subtype", element.getSubtype().get(i), i); 7424 } 7425 if (element.hasRelationship()) { 7426 composeCoding(t, "ContractAssetComponent", "relationship", element.getRelationship(), -1); 7427 } 7428 for (int i = 0; i < element.getContext().size(); i++) { 7429 composeContractAssetContextComponent(t, "ContractAssetComponent", "context", element.getContext().get(i), i); 7430 } 7431 if (element.hasConditionElement()) { 7432 composeString(t, "ContractAssetComponent", "condition", element.getConditionElement(), -1); 7433 } 7434 for (int i = 0; i < element.getPeriodType().size(); i++) { 7435 composeCodeableConcept(t, "ContractAssetComponent", "periodType", element.getPeriodType().get(i), i); 7436 } 7437 for (int i = 0; i < element.getPeriod().size(); i++) { 7438 composePeriod(t, "ContractAssetComponent", "period", element.getPeriod().get(i), i); 7439 } 7440 for (int i = 0; i < element.getUsePeriod().size(); i++) { 7441 composePeriod(t, "ContractAssetComponent", "usePeriod", element.getUsePeriod().get(i), i); 7442 } 7443 if (element.hasTextElement()) { 7444 composeString(t, "ContractAssetComponent", "text", element.getTextElement(), -1); 7445 } 7446 for (int i = 0; i < element.getLinkId().size(); i++) { 7447 composeString(t, "ContractAssetComponent", "linkId", element.getLinkId().get(i), i); 7448 } 7449 for (int i = 0; i < element.getAnswer().size(); i++) { 7450 composeContractAnswerComponent(t, "ContractAssetComponent", "answer", element.getAnswer().get(i), i); 7451 } 7452 for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) { 7453 composeUnsignedInt(t, "ContractAssetComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i); 7454 } 7455 for (int i = 0; i < element.getValuedItem().size(); i++) { 7456 composeContractValuedItemComponent(t, "ContractAssetComponent", "valuedItem", element.getValuedItem().get(i), i); 7457 } 7458 } 7459 7460 protected void composeContractAssetContextComponent(Complex parent, String parentType, String name, Contract.AssetContextComponent element, int index) { 7461 if (element == null) 7462 return; 7463 Complex t; 7464 if (Utilities.noString(parentType)) 7465 t = parent; 7466 else { 7467 t = parent.predicate("fhir:"+parentType+'.'+name); 7468 } 7469 composeBackboneElement(t, "context", name, element, index); 7470 if (element.hasReference()) { 7471 composeReference(t, "AssetContextComponent", "reference", element.getReference(), -1); 7472 } 7473 for (int i = 0; i < element.getCode().size(); i++) { 7474 composeCodeableConcept(t, "AssetContextComponent", "code", element.getCode().get(i), i); 7475 } 7476 if (element.hasTextElement()) { 7477 composeString(t, "AssetContextComponent", "text", element.getTextElement(), -1); 7478 } 7479 } 7480 7481 protected void composeContractValuedItemComponent(Complex parent, String parentType, String name, Contract.ValuedItemComponent element, int index) { 7482 if (element == null) 7483 return; 7484 Complex t; 7485 if (Utilities.noString(parentType)) 7486 t = parent; 7487 else { 7488 t = parent.predicate("fhir:"+parentType+'.'+name); 7489 } 7490 composeBackboneElement(t, "valuedItem", name, element, index); 7491 if (element.hasEntity()) { 7492 composeType(t, "ValuedItemComponent", "entity", element.getEntity(), -1); 7493 } 7494 if (element.hasIdentifier()) { 7495 composeIdentifier(t, "ValuedItemComponent", "identifier", element.getIdentifier(), -1); 7496 } 7497 if (element.hasEffectiveTimeElement()) { 7498 composeDateTime(t, "ValuedItemComponent", "effectiveTime", element.getEffectiveTimeElement(), -1); 7499 } 7500 if (element.hasQuantity()) { 7501 composeQuantity(t, "ValuedItemComponent", "quantity", element.getQuantity(), -1); 7502 } 7503 if (element.hasUnitPrice()) { 7504 composeMoney(t, "ValuedItemComponent", "unitPrice", element.getUnitPrice(), -1); 7505 } 7506 if (element.hasFactorElement()) { 7507 composeDecimal(t, "ValuedItemComponent", "factor", element.getFactorElement(), -1); 7508 } 7509 if (element.hasPointsElement()) { 7510 composeDecimal(t, "ValuedItemComponent", "points", element.getPointsElement(), -1); 7511 } 7512 if (element.hasNet()) { 7513 composeMoney(t, "ValuedItemComponent", "net", element.getNet(), -1); 7514 } 7515 if (element.hasPaymentElement()) { 7516 composeString(t, "ValuedItemComponent", "payment", element.getPaymentElement(), -1); 7517 } 7518 if (element.hasPaymentDateElement()) { 7519 composeDateTime(t, "ValuedItemComponent", "paymentDate", element.getPaymentDateElement(), -1); 7520 } 7521 if (element.hasResponsible()) { 7522 composeReference(t, "ValuedItemComponent", "responsible", element.getResponsible(), -1); 7523 } 7524 if (element.hasRecipient()) { 7525 composeReference(t, "ValuedItemComponent", "recipient", element.getRecipient(), -1); 7526 } 7527 for (int i = 0; i < element.getLinkId().size(); i++) { 7528 composeString(t, "ValuedItemComponent", "linkId", element.getLinkId().get(i), i); 7529 } 7530 for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) { 7531 composeUnsignedInt(t, "ValuedItemComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i); 7532 } 7533 } 7534 7535 protected void composeContractActionComponent(Complex parent, String parentType, String name, Contract.ActionComponent element, int index) { 7536 if (element == null) 7537 return; 7538 Complex t; 7539 if (Utilities.noString(parentType)) 7540 t = parent; 7541 else { 7542 t = parent.predicate("fhir:"+parentType+'.'+name); 7543 } 7544 composeBackboneElement(t, "action", name, element, index); 7545 if (element.hasDoNotPerformElement()) { 7546 composeBoolean(t, "ActionComponent", "doNotPerform", element.getDoNotPerformElement(), -1); 7547 } 7548 if (element.hasType()) { 7549 composeCodeableConcept(t, "ActionComponent", "type", element.getType(), -1); 7550 } 7551 for (int i = 0; i < element.getSubject().size(); i++) { 7552 composeContractActionSubjectComponent(t, "ActionComponent", "subject", element.getSubject().get(i), i); 7553 } 7554 if (element.hasIntent()) { 7555 composeCodeableConcept(t, "ActionComponent", "intent", element.getIntent(), -1); 7556 } 7557 for (int i = 0; i < element.getLinkId().size(); i++) { 7558 composeString(t, "ActionComponent", "linkId", element.getLinkId().get(i), i); 7559 } 7560 if (element.hasStatus()) { 7561 composeCodeableConcept(t, "ActionComponent", "status", element.getStatus(), -1); 7562 } 7563 if (element.hasContext()) { 7564 composeReference(t, "ActionComponent", "context", element.getContext(), -1); 7565 } 7566 for (int i = 0; i < element.getContextLinkId().size(); i++) { 7567 composeString(t, "ActionComponent", "contextLinkId", element.getContextLinkId().get(i), i); 7568 } 7569 if (element.hasOccurrence()) { 7570 composeType(t, "ActionComponent", "occurrence", element.getOccurrence(), -1); 7571 } 7572 for (int i = 0; i < element.getRequester().size(); i++) { 7573 composeReference(t, "ActionComponent", "requester", element.getRequester().get(i), i); 7574 } 7575 for (int i = 0; i < element.getRequesterLinkId().size(); i++) { 7576 composeString(t, "ActionComponent", "requesterLinkId", element.getRequesterLinkId().get(i), i); 7577 } 7578 for (int i = 0; i < element.getPerformerType().size(); i++) { 7579 composeCodeableConcept(t, "ActionComponent", "performerType", element.getPerformerType().get(i), i); 7580 } 7581 if (element.hasPerformerRole()) { 7582 composeCodeableConcept(t, "ActionComponent", "performerRole", element.getPerformerRole(), -1); 7583 } 7584 if (element.hasPerformer()) { 7585 composeReference(t, "ActionComponent", "performer", element.getPerformer(), -1); 7586 } 7587 for (int i = 0; i < element.getPerformerLinkId().size(); i++) { 7588 composeString(t, "ActionComponent", "performerLinkId", element.getPerformerLinkId().get(i), i); 7589 } 7590 for (int i = 0; i < element.getReason().size(); i++) { 7591 composeCodeableReference(t, "ActionComponent", "reason", element.getReason().get(i), i); 7592 } 7593 for (int i = 0; i < element.getReasonLinkId().size(); i++) { 7594 composeString(t, "ActionComponent", "reasonLinkId", element.getReasonLinkId().get(i), i); 7595 } 7596 for (int i = 0; i < element.getNote().size(); i++) { 7597 composeAnnotation(t, "ActionComponent", "note", element.getNote().get(i), i); 7598 } 7599 for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) { 7600 composeUnsignedInt(t, "ActionComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i); 7601 } 7602 } 7603 7604 protected void composeContractActionSubjectComponent(Complex parent, String parentType, String name, Contract.ActionSubjectComponent element, int index) { 7605 if (element == null) 7606 return; 7607 Complex t; 7608 if (Utilities.noString(parentType)) 7609 t = parent; 7610 else { 7611 t = parent.predicate("fhir:"+parentType+'.'+name); 7612 } 7613 composeBackboneElement(t, "subject", name, element, index); 7614 for (int i = 0; i < element.getReference().size(); i++) { 7615 composeReference(t, "ActionSubjectComponent", "reference", element.getReference().get(i), i); 7616 } 7617 if (element.hasRole()) { 7618 composeCodeableConcept(t, "ActionSubjectComponent", "role", element.getRole(), -1); 7619 } 7620 } 7621 7622 protected void composeContractSignatoryComponent(Complex parent, String parentType, String name, Contract.SignatoryComponent element, int index) { 7623 if (element == null) 7624 return; 7625 Complex t; 7626 if (Utilities.noString(parentType)) 7627 t = parent; 7628 else { 7629 t = parent.predicate("fhir:"+parentType+'.'+name); 7630 } 7631 composeBackboneElement(t, "signer", name, element, index); 7632 if (element.hasType()) { 7633 composeCoding(t, "SignatoryComponent", "type", element.getType(), -1); 7634 } 7635 if (element.hasParty()) { 7636 composeReference(t, "SignatoryComponent", "party", element.getParty(), -1); 7637 } 7638 for (int i = 0; i < element.getSignature().size(); i++) { 7639 composeSignature(t, "SignatoryComponent", "signature", element.getSignature().get(i), i); 7640 } 7641 } 7642 7643 protected void composeContractFriendlyLanguageComponent(Complex parent, String parentType, String name, Contract.FriendlyLanguageComponent element, int index) { 7644 if (element == null) 7645 return; 7646 Complex t; 7647 if (Utilities.noString(parentType)) 7648 t = parent; 7649 else { 7650 t = parent.predicate("fhir:"+parentType+'.'+name); 7651 } 7652 composeBackboneElement(t, "friendly", name, element, index); 7653 if (element.hasContent()) { 7654 composeType(t, "FriendlyLanguageComponent", "content", element.getContent(), -1); 7655 } 7656 } 7657 7658 protected void composeContractLegalLanguageComponent(Complex parent, String parentType, String name, Contract.LegalLanguageComponent element, int index) { 7659 if (element == null) 7660 return; 7661 Complex t; 7662 if (Utilities.noString(parentType)) 7663 t = parent; 7664 else { 7665 t = parent.predicate("fhir:"+parentType+'.'+name); 7666 } 7667 composeBackboneElement(t, "legal", name, element, index); 7668 if (element.hasContent()) { 7669 composeType(t, "LegalLanguageComponent", "content", element.getContent(), -1); 7670 } 7671 } 7672 7673 protected void composeContractComputableLanguageComponent(Complex parent, String parentType, String name, Contract.ComputableLanguageComponent element, int index) { 7674 if (element == null) 7675 return; 7676 Complex t; 7677 if (Utilities.noString(parentType)) 7678 t = parent; 7679 else { 7680 t = parent.predicate("fhir:"+parentType+'.'+name); 7681 } 7682 composeBackboneElement(t, "rule", name, element, index); 7683 if (element.hasContent()) { 7684 composeType(t, "ComputableLanguageComponent", "content", element.getContent(), -1); 7685 } 7686 } 7687 7688 protected void composeCoverage(Complex parent, String parentType, String name, Coverage element, int index) { 7689 if (element == null) 7690 return; 7691 Complex t; 7692 if (Utilities.noString(parentType)) 7693 t = parent; 7694 else { 7695 t = parent.predicate("fhir:"+parentType+'.'+name); 7696 } 7697 composeDomainResource(t, "Coverage", name, element, index); 7698 for (int i = 0; i < element.getIdentifier().size(); i++) { 7699 composeIdentifier(t, "Coverage", "identifier", element.getIdentifier().get(i), i); 7700 } 7701 if (element.hasStatusElement()) { 7702 composeEnum(t, "Coverage", "status", element.getStatusElement(), -1); 7703 } 7704 if (element.hasType()) { 7705 composeCodeableConcept(t, "Coverage", "type", element.getType(), -1); 7706 } 7707 if (element.hasPolicyHolder()) { 7708 composeReference(t, "Coverage", "policyHolder", element.getPolicyHolder(), -1); 7709 } 7710 if (element.hasSubscriber()) { 7711 composeReference(t, "Coverage", "subscriber", element.getSubscriber(), -1); 7712 } 7713 if (element.hasSubscriberId()) { 7714 composeIdentifier(t, "Coverage", "subscriberId", element.getSubscriberId(), -1); 7715 } 7716 if (element.hasBeneficiary()) { 7717 composeReference(t, "Coverage", "beneficiary", element.getBeneficiary(), -1); 7718 } 7719 if (element.hasDependentElement()) { 7720 composeString(t, "Coverage", "dependent", element.getDependentElement(), -1); 7721 } 7722 if (element.hasRelationship()) { 7723 composeCodeableConcept(t, "Coverage", "relationship", element.getRelationship(), -1); 7724 } 7725 if (element.hasPeriod()) { 7726 composePeriod(t, "Coverage", "period", element.getPeriod(), -1); 7727 } 7728 for (int i = 0; i < element.getPayor().size(); i++) { 7729 composeReference(t, "Coverage", "payor", element.getPayor().get(i), i); 7730 } 7731 for (int i = 0; i < element.getClass_().size(); i++) { 7732 composeCoverageClassComponent(t, "Coverage", "class", element.getClass_().get(i), i); 7733 } 7734 if (element.hasOrderElement()) { 7735 composePositiveInt(t, "Coverage", "order", element.getOrderElement(), -1); 7736 } 7737 if (element.hasNetworkElement()) { 7738 composeString(t, "Coverage", "network", element.getNetworkElement(), -1); 7739 } 7740 for (int i = 0; i < element.getCostToBeneficiary().size(); i++) { 7741 composeCoverageCostToBeneficiaryComponent(t, "Coverage", "costToBeneficiary", element.getCostToBeneficiary().get(i), i); 7742 } 7743 if (element.hasSubrogationElement()) { 7744 composeBoolean(t, "Coverage", "subrogation", element.getSubrogationElement(), -1); 7745 } 7746 for (int i = 0; i < element.getContract().size(); i++) { 7747 composeReference(t, "Coverage", "contract", element.getContract().get(i), i); 7748 } 7749 } 7750 7751 protected void composeCoverageClassComponent(Complex parent, String parentType, String name, Coverage.ClassComponent element, int index) { 7752 if (element == null) 7753 return; 7754 Complex t; 7755 if (Utilities.noString(parentType)) 7756 t = parent; 7757 else { 7758 t = parent.predicate("fhir:"+parentType+'.'+name); 7759 } 7760 composeBackboneElement(t, "class", name, element, index); 7761 if (element.hasType()) { 7762 composeCodeableConcept(t, "ClassComponent", "type", element.getType(), -1); 7763 } 7764 if (element.hasValueElement()) { 7765 composeString(t, "ClassComponent", "value", element.getValueElement(), -1); 7766 } 7767 if (element.hasNameElement()) { 7768 composeString(t, "ClassComponent", "name", element.getNameElement(), -1); 7769 } 7770 } 7771 7772 protected void composeCoverageCostToBeneficiaryComponent(Complex parent, String parentType, String name, Coverage.CostToBeneficiaryComponent element, int index) { 7773 if (element == null) 7774 return; 7775 Complex t; 7776 if (Utilities.noString(parentType)) 7777 t = parent; 7778 else { 7779 t = parent.predicate("fhir:"+parentType+'.'+name); 7780 } 7781 composeBackboneElement(t, "costToBeneficiary", name, element, index); 7782 if (element.hasType()) { 7783 composeCodeableConcept(t, "CostToBeneficiaryComponent", "type", element.getType(), -1); 7784 } 7785 if (element.hasValue()) { 7786 composeType(t, "CostToBeneficiaryComponent", "value", element.getValue(), -1); 7787 } 7788 for (int i = 0; i < element.getException().size(); i++) { 7789 composeCoverageExemptionComponent(t, "CostToBeneficiaryComponent", "exception", element.getException().get(i), i); 7790 } 7791 } 7792 7793 protected void composeCoverageExemptionComponent(Complex parent, String parentType, String name, Coverage.ExemptionComponent element, int index) { 7794 if (element == null) 7795 return; 7796 Complex t; 7797 if (Utilities.noString(parentType)) 7798 t = parent; 7799 else { 7800 t = parent.predicate("fhir:"+parentType+'.'+name); 7801 } 7802 composeBackboneElement(t, "exception", name, element, index); 7803 if (element.hasType()) { 7804 composeCodeableConcept(t, "ExemptionComponent", "type", element.getType(), -1); 7805 } 7806 if (element.hasPeriod()) { 7807 composePeriod(t, "ExemptionComponent", "period", element.getPeriod(), -1); 7808 } 7809 } 7810 7811 protected void composeCoverageEligibilityRequest(Complex parent, String parentType, String name, CoverageEligibilityRequest element, int index) { 7812 if (element == null) 7813 return; 7814 Complex t; 7815 if (Utilities.noString(parentType)) 7816 t = parent; 7817 else { 7818 t = parent.predicate("fhir:"+parentType+'.'+name); 7819 } 7820 composeDomainResource(t, "CoverageEligibilityRequest", name, element, index); 7821 for (int i = 0; i < element.getIdentifier().size(); i++) { 7822 composeIdentifier(t, "CoverageEligibilityRequest", "identifier", element.getIdentifier().get(i), i); 7823 } 7824 if (element.hasStatusElement()) { 7825 composeEnum(t, "CoverageEligibilityRequest", "status", element.getStatusElement(), -1); 7826 } 7827 if (element.hasPriority()) { 7828 composeCodeableConcept(t, "CoverageEligibilityRequest", "priority", element.getPriority(), -1); 7829 } 7830 for (int i = 0; i < element.getPurpose().size(); i++) { 7831 composeEnum(t, "CoverageEligibilityRequest", "purpose", element.getPurpose().get(i), i); 7832 } 7833 if (element.hasPatient()) { 7834 composeReference(t, "CoverageEligibilityRequest", "patient", element.getPatient(), -1); 7835 } 7836 if (element.hasServiced()) { 7837 composeType(t, "CoverageEligibilityRequest", "serviced", element.getServiced(), -1); 7838 } 7839 if (element.hasCreatedElement()) { 7840 composeDateTime(t, "CoverageEligibilityRequest", "created", element.getCreatedElement(), -1); 7841 } 7842 if (element.hasEnterer()) { 7843 composeReference(t, "CoverageEligibilityRequest", "enterer", element.getEnterer(), -1); 7844 } 7845 if (element.hasProvider()) { 7846 composeReference(t, "CoverageEligibilityRequest", "provider", element.getProvider(), -1); 7847 } 7848 if (element.hasInsurer()) { 7849 composeReference(t, "CoverageEligibilityRequest", "insurer", element.getInsurer(), -1); 7850 } 7851 if (element.hasFacility()) { 7852 composeReference(t, "CoverageEligibilityRequest", "facility", element.getFacility(), -1); 7853 } 7854 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 7855 composeCoverageEligibilityRequestSupportingInformationComponent(t, "CoverageEligibilityRequest", "supportingInfo", element.getSupportingInfo().get(i), i); 7856 } 7857 for (int i = 0; i < element.getInsurance().size(); i++) { 7858 composeCoverageEligibilityRequestInsuranceComponent(t, "CoverageEligibilityRequest", "insurance", element.getInsurance().get(i), i); 7859 } 7860 for (int i = 0; i < element.getItem().size(); i++) { 7861 composeCoverageEligibilityRequestDetailsComponent(t, "CoverageEligibilityRequest", "item", element.getItem().get(i), i); 7862 } 7863 } 7864 7865 protected void composeCoverageEligibilityRequestSupportingInformationComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.SupportingInformationComponent element, int index) { 7866 if (element == null) 7867 return; 7868 Complex t; 7869 if (Utilities.noString(parentType)) 7870 t = parent; 7871 else { 7872 t = parent.predicate("fhir:"+parentType+'.'+name); 7873 } 7874 composeBackboneElement(t, "supportingInfo", name, element, index); 7875 if (element.hasSequenceElement()) { 7876 composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1); 7877 } 7878 if (element.hasInformation()) { 7879 composeReference(t, "SupportingInformationComponent", "information", element.getInformation(), -1); 7880 } 7881 if (element.hasAppliesToAllElement()) { 7882 composeBoolean(t, "SupportingInformationComponent", "appliesToAll", element.getAppliesToAllElement(), -1); 7883 } 7884 } 7885 7886 protected void composeCoverageEligibilityRequestInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.InsuranceComponent 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, "insurance", name, element, index); 7896 if (element.hasFocalElement()) { 7897 composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1); 7898 } 7899 if (element.hasCoverage()) { 7900 composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1); 7901 } 7902 if (element.hasBusinessArrangementElement()) { 7903 composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1); 7904 } 7905 } 7906 7907 protected void composeCoverageEligibilityRequestDetailsComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DetailsComponent element, int index) { 7908 if (element == null) 7909 return; 7910 Complex t; 7911 if (Utilities.noString(parentType)) 7912 t = parent; 7913 else { 7914 t = parent.predicate("fhir:"+parentType+'.'+name); 7915 } 7916 composeBackboneElement(t, "item", name, element, index); 7917 for (int i = 0; i < element.getSupportingInfoSequence().size(); i++) { 7918 composePositiveInt(t, "DetailsComponent", "supportingInfoSequence", element.getSupportingInfoSequence().get(i), i); 7919 } 7920 if (element.hasCategory()) { 7921 composeCodeableConcept(t, "DetailsComponent", "category", element.getCategory(), -1); 7922 } 7923 if (element.hasProductOrService()) { 7924 composeCodeableConcept(t, "DetailsComponent", "productOrService", element.getProductOrService(), -1); 7925 } 7926 for (int i = 0; i < element.getModifier().size(); i++) { 7927 composeCodeableConcept(t, "DetailsComponent", "modifier", element.getModifier().get(i), i); 7928 } 7929 if (element.hasProvider()) { 7930 composeReference(t, "DetailsComponent", "provider", element.getProvider(), -1); 7931 } 7932 if (element.hasQuantity()) { 7933 composeQuantity(t, "DetailsComponent", "quantity", element.getQuantity(), -1); 7934 } 7935 if (element.hasUnitPrice()) { 7936 composeMoney(t, "DetailsComponent", "unitPrice", element.getUnitPrice(), -1); 7937 } 7938 if (element.hasFacility()) { 7939 composeReference(t, "DetailsComponent", "facility", element.getFacility(), -1); 7940 } 7941 for (int i = 0; i < element.getDiagnosis().size(); i++) { 7942 composeCoverageEligibilityRequestDiagnosisComponent(t, "DetailsComponent", "diagnosis", element.getDiagnosis().get(i), i); 7943 } 7944 for (int i = 0; i < element.getDetail().size(); i++) { 7945 composeReference(t, "DetailsComponent", "detail", element.getDetail().get(i), i); 7946 } 7947 } 7948 7949 protected void composeCoverageEligibilityRequestDiagnosisComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DiagnosisComponent element, int index) { 7950 if (element == null) 7951 return; 7952 Complex t; 7953 if (Utilities.noString(parentType)) 7954 t = parent; 7955 else { 7956 t = parent.predicate("fhir:"+parentType+'.'+name); 7957 } 7958 composeBackboneElement(t, "diagnosis", name, element, index); 7959 if (element.hasDiagnosis()) { 7960 composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1); 7961 } 7962 } 7963 7964 protected void composeCoverageEligibilityResponse(Complex parent, String parentType, String name, CoverageEligibilityResponse element, int index) { 7965 if (element == null) 7966 return; 7967 Complex t; 7968 if (Utilities.noString(parentType)) 7969 t = parent; 7970 else { 7971 t = parent.predicate("fhir:"+parentType+'.'+name); 7972 } 7973 composeDomainResource(t, "CoverageEligibilityResponse", name, element, index); 7974 for (int i = 0; i < element.getIdentifier().size(); i++) { 7975 composeIdentifier(t, "CoverageEligibilityResponse", "identifier", element.getIdentifier().get(i), i); 7976 } 7977 if (element.hasStatusElement()) { 7978 composeEnum(t, "CoverageEligibilityResponse", "status", element.getStatusElement(), -1); 7979 } 7980 for (int i = 0; i < element.getPurpose().size(); i++) { 7981 composeEnum(t, "CoverageEligibilityResponse", "purpose", element.getPurpose().get(i), i); 7982 } 7983 if (element.hasPatient()) { 7984 composeReference(t, "CoverageEligibilityResponse", "patient", element.getPatient(), -1); 7985 } 7986 if (element.hasServiced()) { 7987 composeType(t, "CoverageEligibilityResponse", "serviced", element.getServiced(), -1); 7988 } 7989 if (element.hasCreatedElement()) { 7990 composeDateTime(t, "CoverageEligibilityResponse", "created", element.getCreatedElement(), -1); 7991 } 7992 if (element.hasRequestor()) { 7993 composeReference(t, "CoverageEligibilityResponse", "requestor", element.getRequestor(), -1); 7994 } 7995 if (element.hasRequest()) { 7996 composeReference(t, "CoverageEligibilityResponse", "request", element.getRequest(), -1); 7997 } 7998 if (element.hasOutcomeElement()) { 7999 composeEnum(t, "CoverageEligibilityResponse", "outcome", element.getOutcomeElement(), -1); 8000 } 8001 if (element.hasDispositionElement()) { 8002 composeString(t, "CoverageEligibilityResponse", "disposition", element.getDispositionElement(), -1); 8003 } 8004 if (element.hasInsurer()) { 8005 composeReference(t, "CoverageEligibilityResponse", "insurer", element.getInsurer(), -1); 8006 } 8007 for (int i = 0; i < element.getInsurance().size(); i++) { 8008 composeCoverageEligibilityResponseInsuranceComponent(t, "CoverageEligibilityResponse", "insurance", element.getInsurance().get(i), i); 8009 } 8010 if (element.hasPreAuthRefElement()) { 8011 composeString(t, "CoverageEligibilityResponse", "preAuthRef", element.getPreAuthRefElement(), -1); 8012 } 8013 if (element.hasForm()) { 8014 composeCodeableConcept(t, "CoverageEligibilityResponse", "form", element.getForm(), -1); 8015 } 8016 for (int i = 0; i < element.getError().size(); i++) { 8017 composeCoverageEligibilityResponseErrorsComponent(t, "CoverageEligibilityResponse", "error", element.getError().get(i), i); 8018 } 8019 } 8020 8021 protected void composeCoverageEligibilityResponseInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.InsuranceComponent element, int index) { 8022 if (element == null) 8023 return; 8024 Complex t; 8025 if (Utilities.noString(parentType)) 8026 t = parent; 8027 else { 8028 t = parent.predicate("fhir:"+parentType+'.'+name); 8029 } 8030 composeBackboneElement(t, "insurance", name, element, index); 8031 if (element.hasCoverage()) { 8032 composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1); 8033 } 8034 if (element.hasInforceElement()) { 8035 composeBoolean(t, "InsuranceComponent", "inforce", element.getInforceElement(), -1); 8036 } 8037 if (element.hasBenefitPeriod()) { 8038 composePeriod(t, "InsuranceComponent", "benefitPeriod", element.getBenefitPeriod(), -1); 8039 } 8040 for (int i = 0; i < element.getItem().size(); i++) { 8041 composeCoverageEligibilityResponseItemsComponent(t, "InsuranceComponent", "item", element.getItem().get(i), i); 8042 } 8043 } 8044 8045 protected void composeCoverageEligibilityResponseItemsComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.ItemsComponent element, int index) { 8046 if (element == null) 8047 return; 8048 Complex t; 8049 if (Utilities.noString(parentType)) 8050 t = parent; 8051 else { 8052 t = parent.predicate("fhir:"+parentType+'.'+name); 8053 } 8054 composeBackboneElement(t, "item", name, element, index); 8055 if (element.hasCategory()) { 8056 composeCodeableConcept(t, "ItemsComponent", "category", element.getCategory(), -1); 8057 } 8058 if (element.hasProductOrService()) { 8059 composeCodeableConcept(t, "ItemsComponent", "productOrService", element.getProductOrService(), -1); 8060 } 8061 for (int i = 0; i < element.getModifier().size(); i++) { 8062 composeCodeableConcept(t, "ItemsComponent", "modifier", element.getModifier().get(i), i); 8063 } 8064 if (element.hasProvider()) { 8065 composeReference(t, "ItemsComponent", "provider", element.getProvider(), -1); 8066 } 8067 if (element.hasExcludedElement()) { 8068 composeBoolean(t, "ItemsComponent", "excluded", element.getExcludedElement(), -1); 8069 } 8070 if (element.hasNameElement()) { 8071 composeString(t, "ItemsComponent", "name", element.getNameElement(), -1); 8072 } 8073 if (element.hasDescriptionElement()) { 8074 composeString(t, "ItemsComponent", "description", element.getDescriptionElement(), -1); 8075 } 8076 if (element.hasNetwork()) { 8077 composeCodeableConcept(t, "ItemsComponent", "network", element.getNetwork(), -1); 8078 } 8079 if (element.hasUnit()) { 8080 composeCodeableConcept(t, "ItemsComponent", "unit", element.getUnit(), -1); 8081 } 8082 if (element.hasTerm()) { 8083 composeCodeableConcept(t, "ItemsComponent", "term", element.getTerm(), -1); 8084 } 8085 for (int i = 0; i < element.getBenefit().size(); i++) { 8086 composeCoverageEligibilityResponseBenefitComponent(t, "ItemsComponent", "benefit", element.getBenefit().get(i), i); 8087 } 8088 if (element.hasAuthorizationRequiredElement()) { 8089 composeBoolean(t, "ItemsComponent", "authorizationRequired", element.getAuthorizationRequiredElement(), -1); 8090 } 8091 for (int i = 0; i < element.getAuthorizationSupporting().size(); i++) { 8092 composeCodeableConcept(t, "ItemsComponent", "authorizationSupporting", element.getAuthorizationSupporting().get(i), i); 8093 } 8094 if (element.hasAuthorizationUrlElement()) { 8095 composeUri(t, "ItemsComponent", "authorizationUrl", element.getAuthorizationUrlElement(), -1); 8096 } 8097 } 8098 8099 protected void composeCoverageEligibilityResponseBenefitComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.BenefitComponent element, int index) { 8100 if (element == null) 8101 return; 8102 Complex t; 8103 if (Utilities.noString(parentType)) 8104 t = parent; 8105 else { 8106 t = parent.predicate("fhir:"+parentType+'.'+name); 8107 } 8108 composeBackboneElement(t, "benefit", name, element, index); 8109 if (element.hasType()) { 8110 composeCodeableConcept(t, "BenefitComponent", "type", element.getType(), -1); 8111 } 8112 if (element.hasAllowed()) { 8113 composeType(t, "BenefitComponent", "allowed", element.getAllowed(), -1); 8114 } 8115 if (element.hasUsed()) { 8116 composeType(t, "BenefitComponent", "used", element.getUsed(), -1); 8117 } 8118 } 8119 8120 protected void composeCoverageEligibilityResponseErrorsComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.ErrorsComponent element, int index) { 8121 if (element == null) 8122 return; 8123 Complex t; 8124 if (Utilities.noString(parentType)) 8125 t = parent; 8126 else { 8127 t = parent.predicate("fhir:"+parentType+'.'+name); 8128 } 8129 composeBackboneElement(t, "error", name, element, index); 8130 if (element.hasCode()) { 8131 composeCodeableConcept(t, "ErrorsComponent", "code", element.getCode(), -1); 8132 } 8133 } 8134 8135 protected void composeDetectedIssue(Complex parent, String parentType, String name, DetectedIssue element, int index) { 8136 if (element == null) 8137 return; 8138 Complex t; 8139 if (Utilities.noString(parentType)) 8140 t = parent; 8141 else { 8142 t = parent.predicate("fhir:"+parentType+'.'+name); 8143 } 8144 composeDomainResource(t, "DetectedIssue", name, element, index); 8145 for (int i = 0; i < element.getIdentifier().size(); i++) { 8146 composeIdentifier(t, "DetectedIssue", "identifier", element.getIdentifier().get(i), i); 8147 } 8148 if (element.hasStatusElement()) { 8149 composeEnum(t, "DetectedIssue", "status", element.getStatusElement(), -1); 8150 } 8151 if (element.hasCode()) { 8152 composeCodeableConcept(t, "DetectedIssue", "code", element.getCode(), -1); 8153 } 8154 if (element.hasSeverityElement()) { 8155 composeEnum(t, "DetectedIssue", "severity", element.getSeverityElement(), -1); 8156 } 8157 if (element.hasPatient()) { 8158 composeReference(t, "DetectedIssue", "patient", element.getPatient(), -1); 8159 } 8160 if (element.hasIdentified()) { 8161 composeType(t, "DetectedIssue", "identified", element.getIdentified(), -1); 8162 } 8163 if (element.hasAuthor()) { 8164 composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1); 8165 } 8166 for (int i = 0; i < element.getImplicated().size(); i++) { 8167 composeReference(t, "DetectedIssue", "implicated", element.getImplicated().get(i), i); 8168 } 8169 for (int i = 0; i < element.getEvidence().size(); i++) { 8170 composeDetectedIssueEvidenceComponent(t, "DetectedIssue", "evidence", element.getEvidence().get(i), i); 8171 } 8172 if (element.hasDetailElement()) { 8173 composeString(t, "DetectedIssue", "detail", element.getDetailElement(), -1); 8174 } 8175 if (element.hasReferenceElement()) { 8176 composeUri(t, "DetectedIssue", "reference", element.getReferenceElement(), -1); 8177 } 8178 for (int i = 0; i < element.getMitigation().size(); i++) { 8179 composeDetectedIssueMitigationComponent(t, "DetectedIssue", "mitigation", element.getMitigation().get(i), i); 8180 } 8181 } 8182 8183 protected void composeDetectedIssueEvidenceComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueEvidenceComponent element, int index) { 8184 if (element == null) 8185 return; 8186 Complex t; 8187 if (Utilities.noString(parentType)) 8188 t = parent; 8189 else { 8190 t = parent.predicate("fhir:"+parentType+'.'+name); 8191 } 8192 composeBackboneElement(t, "evidence", name, element, index); 8193 for (int i = 0; i < element.getCode().size(); i++) { 8194 composeCodeableConcept(t, "DetectedIssueEvidenceComponent", "code", element.getCode().get(i), i); 8195 } 8196 for (int i = 0; i < element.getDetail().size(); i++) { 8197 composeReference(t, "DetectedIssueEvidenceComponent", "detail", element.getDetail().get(i), i); 8198 } 8199 } 8200 8201 protected void composeDetectedIssueMitigationComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueMitigationComponent element, int index) { 8202 if (element == null) 8203 return; 8204 Complex t; 8205 if (Utilities.noString(parentType)) 8206 t = parent; 8207 else { 8208 t = parent.predicate("fhir:"+parentType+'.'+name); 8209 } 8210 composeBackboneElement(t, "mitigation", name, element, index); 8211 if (element.hasAction()) { 8212 composeCodeableConcept(t, "DetectedIssueMitigationComponent", "action", element.getAction(), -1); 8213 } 8214 if (element.hasDateElement()) { 8215 composeDateTime(t, "DetectedIssueMitigationComponent", "date", element.getDateElement(), -1); 8216 } 8217 if (element.hasAuthor()) { 8218 composeReference(t, "DetectedIssueMitigationComponent", "author", element.getAuthor(), -1); 8219 } 8220 } 8221 8222 protected void composeDevice(Complex parent, String parentType, String name, Device element, int index) { 8223 if (element == null) 8224 return; 8225 Complex t; 8226 if (Utilities.noString(parentType)) 8227 t = parent; 8228 else { 8229 t = parent.predicate("fhir:"+parentType+'.'+name); 8230 } 8231 composeDomainResource(t, "Device", name, element, index); 8232 for (int i = 0; i < element.getIdentifier().size(); i++) { 8233 composeIdentifier(t, "Device", "identifier", element.getIdentifier().get(i), i); 8234 } 8235 if (element.hasDefinition()) { 8236 composeReference(t, "Device", "definition", element.getDefinition(), -1); 8237 } 8238 for (int i = 0; i < element.getUdiCarrier().size(); i++) { 8239 composeDeviceUdiCarrierComponent(t, "Device", "udiCarrier", element.getUdiCarrier().get(i), i); 8240 } 8241 if (element.hasStatusElement()) { 8242 composeEnum(t, "Device", "status", element.getStatusElement(), -1); 8243 } 8244 for (int i = 0; i < element.getStatusReason().size(); i++) { 8245 composeCodeableConcept(t, "Device", "statusReason", element.getStatusReason().get(i), i); 8246 } 8247 if (element.hasDistinctIdentifierElement()) { 8248 composeString(t, "Device", "distinctIdentifier", element.getDistinctIdentifierElement(), -1); 8249 } 8250 if (element.hasManufacturerElement()) { 8251 composeString(t, "Device", "manufacturer", element.getManufacturerElement(), -1); 8252 } 8253 if (element.hasManufactureDateElement()) { 8254 composeDateTime(t, "Device", "manufactureDate", element.getManufactureDateElement(), -1); 8255 } 8256 if (element.hasExpirationDateElement()) { 8257 composeDateTime(t, "Device", "expirationDate", element.getExpirationDateElement(), -1); 8258 } 8259 if (element.hasLotNumberElement()) { 8260 composeString(t, "Device", "lotNumber", element.getLotNumberElement(), -1); 8261 } 8262 if (element.hasSerialNumberElement()) { 8263 composeString(t, "Device", "serialNumber", element.getSerialNumberElement(), -1); 8264 } 8265 for (int i = 0; i < element.getDeviceName().size(); i++) { 8266 composeDeviceDeviceNameComponent(t, "Device", "deviceName", element.getDeviceName().get(i), i); 8267 } 8268 if (element.hasModelNumberElement()) { 8269 composeString(t, "Device", "modelNumber", element.getModelNumberElement(), -1); 8270 } 8271 if (element.hasPartNumberElement()) { 8272 composeString(t, "Device", "partNumber", element.getPartNumberElement(), -1); 8273 } 8274 if (element.hasType()) { 8275 composeCodeableConcept(t, "Device", "type", element.getType(), -1); 8276 } 8277 for (int i = 0; i < element.getSpecialization().size(); i++) { 8278 composeDeviceSpecializationComponent(t, "Device", "specialization", element.getSpecialization().get(i), i); 8279 } 8280 for (int i = 0; i < element.getVersion().size(); i++) { 8281 composeDeviceVersionComponent(t, "Device", "version", element.getVersion().get(i), i); 8282 } 8283 for (int i = 0; i < element.getProperty().size(); i++) { 8284 composeDevicePropertyComponent(t, "Device", "property", element.getProperty().get(i), i); 8285 } 8286 if (element.hasPatient()) { 8287 composeReference(t, "Device", "patient", element.getPatient(), -1); 8288 } 8289 if (element.hasOwner()) { 8290 composeReference(t, "Device", "owner", element.getOwner(), -1); 8291 } 8292 for (int i = 0; i < element.getContact().size(); i++) { 8293 composeContactPoint(t, "Device", "contact", element.getContact().get(i), i); 8294 } 8295 if (element.hasLocation()) { 8296 composeReference(t, "Device", "location", element.getLocation(), -1); 8297 } 8298 if (element.hasUrlElement()) { 8299 composeUri(t, "Device", "url", element.getUrlElement(), -1); 8300 } 8301 for (int i = 0; i < element.getNote().size(); i++) { 8302 composeAnnotation(t, "Device", "note", element.getNote().get(i), i); 8303 } 8304 for (int i = 0; i < element.getSafety().size(); i++) { 8305 composeCodeableConcept(t, "Device", "safety", element.getSafety().get(i), i); 8306 } 8307 if (element.hasParent()) { 8308 composeReference(t, "Device", "parent", element.getParent(), -1); 8309 } 8310 } 8311 8312 protected void composeDeviceUdiCarrierComponent(Complex parent, String parentType, String name, Device.DeviceUdiCarrierComponent element, int index) { 8313 if (element == null) 8314 return; 8315 Complex t; 8316 if (Utilities.noString(parentType)) 8317 t = parent; 8318 else { 8319 t = parent.predicate("fhir:"+parentType+'.'+name); 8320 } 8321 composeBackboneElement(t, "udiCarrier", name, element, index); 8322 if (element.hasDeviceIdentifierElement()) { 8323 composeString(t, "DeviceUdiCarrierComponent", "deviceIdentifier", element.getDeviceIdentifierElement(), -1); 8324 } 8325 if (element.hasIssuerElement()) { 8326 composeUri(t, "DeviceUdiCarrierComponent", "issuer", element.getIssuerElement(), -1); 8327 } 8328 if (element.hasJurisdictionElement()) { 8329 composeUri(t, "DeviceUdiCarrierComponent", "jurisdiction", element.getJurisdictionElement(), -1); 8330 } 8331 if (element.hasCarrierAIDCElement()) { 8332 composeBase64Binary(t, "DeviceUdiCarrierComponent", "carrierAIDC", element.getCarrierAIDCElement(), -1); 8333 } 8334 if (element.hasCarrierHRFElement()) { 8335 composeString(t, "DeviceUdiCarrierComponent", "carrierHRF", element.getCarrierHRFElement(), -1); 8336 } 8337 if (element.hasEntryTypeElement()) { 8338 composeEnum(t, "DeviceUdiCarrierComponent", "entryType", element.getEntryTypeElement(), -1); 8339 } 8340 } 8341 8342 protected void composeDeviceDeviceNameComponent(Complex parent, String parentType, String name, Device.DeviceDeviceNameComponent element, int index) { 8343 if (element == null) 8344 return; 8345 Complex t; 8346 if (Utilities.noString(parentType)) 8347 t = parent; 8348 else { 8349 t = parent.predicate("fhir:"+parentType+'.'+name); 8350 } 8351 composeBackboneElement(t, "deviceName", name, element, index); 8352 if (element.hasNameElement()) { 8353 composeString(t, "DeviceDeviceNameComponent", "name", element.getNameElement(), -1); 8354 } 8355 if (element.hasTypeElement()) { 8356 composeEnum(t, "DeviceDeviceNameComponent", "type", element.getTypeElement(), -1); 8357 } 8358 } 8359 8360 protected void composeDeviceSpecializationComponent(Complex parent, String parentType, String name, Device.DeviceSpecializationComponent element, int index) { 8361 if (element == null) 8362 return; 8363 Complex t; 8364 if (Utilities.noString(parentType)) 8365 t = parent; 8366 else { 8367 t = parent.predicate("fhir:"+parentType+'.'+name); 8368 } 8369 composeBackboneElement(t, "specialization", name, element, index); 8370 if (element.hasSystemType()) { 8371 composeCodeableConcept(t, "DeviceSpecializationComponent", "systemType", element.getSystemType(), -1); 8372 } 8373 if (element.hasVersionElement()) { 8374 composeString(t, "DeviceSpecializationComponent", "version", element.getVersionElement(), -1); 8375 } 8376 } 8377 8378 protected void composeDeviceVersionComponent(Complex parent, String parentType, String name, Device.DeviceVersionComponent element, int index) { 8379 if (element == null) 8380 return; 8381 Complex t; 8382 if (Utilities.noString(parentType)) 8383 t = parent; 8384 else { 8385 t = parent.predicate("fhir:"+parentType+'.'+name); 8386 } 8387 composeBackboneElement(t, "version", name, element, index); 8388 if (element.hasType()) { 8389 composeCodeableConcept(t, "DeviceVersionComponent", "type", element.getType(), -1); 8390 } 8391 if (element.hasComponent()) { 8392 composeIdentifier(t, "DeviceVersionComponent", "component", element.getComponent(), -1); 8393 } 8394 if (element.hasValueElement()) { 8395 composeString(t, "DeviceVersionComponent", "value", element.getValueElement(), -1); 8396 } 8397 } 8398 8399 protected void composeDevicePropertyComponent(Complex parent, String parentType, String name, Device.DevicePropertyComponent element, int index) { 8400 if (element == null) 8401 return; 8402 Complex t; 8403 if (Utilities.noString(parentType)) 8404 t = parent; 8405 else { 8406 t = parent.predicate("fhir:"+parentType+'.'+name); 8407 } 8408 composeBackboneElement(t, "property", name, element, index); 8409 if (element.hasType()) { 8410 composeCodeableConcept(t, "DevicePropertyComponent", "type", element.getType(), -1); 8411 } 8412 for (int i = 0; i < element.getValueQuantity().size(); i++) { 8413 composeQuantity(t, "DevicePropertyComponent", "valueQuantity", element.getValueQuantity().get(i), i); 8414 } 8415 for (int i = 0; i < element.getValueCode().size(); i++) { 8416 composeCodeableConcept(t, "DevicePropertyComponent", "valueCode", element.getValueCode().get(i), i); 8417 } 8418 } 8419 8420 protected void composeDeviceDefinition(Complex parent, String parentType, String name, DeviceDefinition element, int index) { 8421 if (element == null) 8422 return; 8423 Complex t; 8424 if (Utilities.noString(parentType)) 8425 t = parent; 8426 else { 8427 t = parent.predicate("fhir:"+parentType+'.'+name); 8428 } 8429 composeDomainResource(t, "DeviceDefinition", name, element, index); 8430 for (int i = 0; i < element.getIdentifier().size(); i++) { 8431 composeIdentifier(t, "DeviceDefinition", "identifier", element.getIdentifier().get(i), i); 8432 } 8433 for (int i = 0; i < element.getUdiDeviceIdentifier().size(); i++) { 8434 composeDeviceDefinitionUdiDeviceIdentifierComponent(t, "DeviceDefinition", "udiDeviceIdentifier", element.getUdiDeviceIdentifier().get(i), i); 8435 } 8436 if (element.hasManufacturer()) { 8437 composeType(t, "DeviceDefinition", "manufacturer", element.getManufacturer(), -1); 8438 } 8439 for (int i = 0; i < element.getDeviceName().size(); i++) { 8440 composeDeviceDefinitionDeviceNameComponent(t, "DeviceDefinition", "deviceName", element.getDeviceName().get(i), i); 8441 } 8442 if (element.hasModelNumberElement()) { 8443 composeString(t, "DeviceDefinition", "modelNumber", element.getModelNumberElement(), -1); 8444 } 8445 if (element.hasType()) { 8446 composeCodeableConcept(t, "DeviceDefinition", "type", element.getType(), -1); 8447 } 8448 for (int i = 0; i < element.getSpecialization().size(); i++) { 8449 composeDeviceDefinitionSpecializationComponent(t, "DeviceDefinition", "specialization", element.getSpecialization().get(i), i); 8450 } 8451 for (int i = 0; i < element.getVersion().size(); i++) { 8452 composeString(t, "DeviceDefinition", "version", element.getVersion().get(i), i); 8453 } 8454 for (int i = 0; i < element.getSafety().size(); i++) { 8455 composeCodeableConcept(t, "DeviceDefinition", "safety", element.getSafety().get(i), i); 8456 } 8457 for (int i = 0; i < element.getShelfLifeStorage().size(); i++) { 8458 composeProductShelfLife(t, "DeviceDefinition", "shelfLifeStorage", element.getShelfLifeStorage().get(i), i); 8459 } 8460 if (element.hasPhysicalCharacteristics()) { 8461 composeProdCharacteristic(t, "DeviceDefinition", "physicalCharacteristics", element.getPhysicalCharacteristics(), -1); 8462 } 8463 for (int i = 0; i < element.getLanguageCode().size(); i++) { 8464 composeCodeableConcept(t, "DeviceDefinition", "languageCode", element.getLanguageCode().get(i), i); 8465 } 8466 for (int i = 0; i < element.getCapability().size(); i++) { 8467 composeDeviceDefinitionCapabilityComponent(t, "DeviceDefinition", "capability", element.getCapability().get(i), i); 8468 } 8469 for (int i = 0; i < element.getProperty().size(); i++) { 8470 composeDeviceDefinitionPropertyComponent(t, "DeviceDefinition", "property", element.getProperty().get(i), i); 8471 } 8472 if (element.hasOwner()) { 8473 composeReference(t, "DeviceDefinition", "owner", element.getOwner(), -1); 8474 } 8475 for (int i = 0; i < element.getContact().size(); i++) { 8476 composeContactPoint(t, "DeviceDefinition", "contact", element.getContact().get(i), i); 8477 } 8478 if (element.hasUrlElement()) { 8479 composeUri(t, "DeviceDefinition", "url", element.getUrlElement(), -1); 8480 } 8481 if (element.hasOnlineInformationElement()) { 8482 composeUri(t, "DeviceDefinition", "onlineInformation", element.getOnlineInformationElement(), -1); 8483 } 8484 for (int i = 0; i < element.getNote().size(); i++) { 8485 composeAnnotation(t, "DeviceDefinition", "note", element.getNote().get(i), i); 8486 } 8487 if (element.hasQuantity()) { 8488 composeQuantity(t, "DeviceDefinition", "quantity", element.getQuantity(), -1); 8489 } 8490 if (element.hasParentDevice()) { 8491 composeReference(t, "DeviceDefinition", "parentDevice", element.getParentDevice(), -1); 8492 } 8493 for (int i = 0; i < element.getMaterial().size(); i++) { 8494 composeDeviceDefinitionMaterialComponent(t, "DeviceDefinition", "material", element.getMaterial().get(i), i); 8495 } 8496 } 8497 8498 protected void composeDeviceDefinitionUdiDeviceIdentifierComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionUdiDeviceIdentifierComponent element, int index) { 8499 if (element == null) 8500 return; 8501 Complex t; 8502 if (Utilities.noString(parentType)) 8503 t = parent; 8504 else { 8505 t = parent.predicate("fhir:"+parentType+'.'+name); 8506 } 8507 composeBackboneElement(t, "udiDeviceIdentifier", name, element, index); 8508 if (element.hasDeviceIdentifierElement()) { 8509 composeString(t, "DeviceDefinitionUdiDeviceIdentifierComponent", "deviceIdentifier", element.getDeviceIdentifierElement(), -1); 8510 } 8511 if (element.hasIssuerElement()) { 8512 composeUri(t, "DeviceDefinitionUdiDeviceIdentifierComponent", "issuer", element.getIssuerElement(), -1); 8513 } 8514 if (element.hasJurisdictionElement()) { 8515 composeUri(t, "DeviceDefinitionUdiDeviceIdentifierComponent", "jurisdiction", element.getJurisdictionElement(), -1); 8516 } 8517 } 8518 8519 protected void composeDeviceDefinitionDeviceNameComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionDeviceNameComponent element, int index) { 8520 if (element == null) 8521 return; 8522 Complex t; 8523 if (Utilities.noString(parentType)) 8524 t = parent; 8525 else { 8526 t = parent.predicate("fhir:"+parentType+'.'+name); 8527 } 8528 composeBackboneElement(t, "deviceName", name, element, index); 8529 if (element.hasNameElement()) { 8530 composeString(t, "DeviceDefinitionDeviceNameComponent", "name", element.getNameElement(), -1); 8531 } 8532 if (element.hasTypeElement()) { 8533 composeEnum(t, "DeviceDefinitionDeviceNameComponent", "type", element.getTypeElement(), -1); 8534 } 8535 } 8536 8537 protected void composeDeviceDefinitionSpecializationComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionSpecializationComponent element, int index) { 8538 if (element == null) 8539 return; 8540 Complex t; 8541 if (Utilities.noString(parentType)) 8542 t = parent; 8543 else { 8544 t = parent.predicate("fhir:"+parentType+'.'+name); 8545 } 8546 composeBackboneElement(t, "specialization", name, element, index); 8547 if (element.hasSystemTypeElement()) { 8548 composeString(t, "DeviceDefinitionSpecializationComponent", "systemType", element.getSystemTypeElement(), -1); 8549 } 8550 if (element.hasVersionElement()) { 8551 composeString(t, "DeviceDefinitionSpecializationComponent", "version", element.getVersionElement(), -1); 8552 } 8553 } 8554 8555 protected void composeDeviceDefinitionCapabilityComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionCapabilityComponent element, int index) { 8556 if (element == null) 8557 return; 8558 Complex t; 8559 if (Utilities.noString(parentType)) 8560 t = parent; 8561 else { 8562 t = parent.predicate("fhir:"+parentType+'.'+name); 8563 } 8564 composeBackboneElement(t, "capability", name, element, index); 8565 if (element.hasType()) { 8566 composeCodeableConcept(t, "DeviceDefinitionCapabilityComponent", "type", element.getType(), -1); 8567 } 8568 for (int i = 0; i < element.getDescription().size(); i++) { 8569 composeCodeableConcept(t, "DeviceDefinitionCapabilityComponent", "description", element.getDescription().get(i), i); 8570 } 8571 } 8572 8573 protected void composeDeviceDefinitionPropertyComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionPropertyComponent element, int index) { 8574 if (element == null) 8575 return; 8576 Complex t; 8577 if (Utilities.noString(parentType)) 8578 t = parent; 8579 else { 8580 t = parent.predicate("fhir:"+parentType+'.'+name); 8581 } 8582 composeBackboneElement(t, "property", name, element, index); 8583 if (element.hasType()) { 8584 composeCodeableConcept(t, "DeviceDefinitionPropertyComponent", "type", element.getType(), -1); 8585 } 8586 for (int i = 0; i < element.getValueQuantity().size(); i++) { 8587 composeQuantity(t, "DeviceDefinitionPropertyComponent", "valueQuantity", element.getValueQuantity().get(i), i); 8588 } 8589 for (int i = 0; i < element.getValueCode().size(); i++) { 8590 composeCodeableConcept(t, "DeviceDefinitionPropertyComponent", "valueCode", element.getValueCode().get(i), i); 8591 } 8592 } 8593 8594 protected void composeDeviceDefinitionMaterialComponent(Complex parent, String parentType, String name, DeviceDefinition.DeviceDefinitionMaterialComponent 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 composeBackboneElement(t, "material", name, element, index); 8604 if (element.hasSubstance()) { 8605 composeCodeableConcept(t, "DeviceDefinitionMaterialComponent", "substance", element.getSubstance(), -1); 8606 } 8607 if (element.hasAlternateElement()) { 8608 composeBoolean(t, "DeviceDefinitionMaterialComponent", "alternate", element.getAlternateElement(), -1); 8609 } 8610 if (element.hasAllergenicIndicatorElement()) { 8611 composeBoolean(t, "DeviceDefinitionMaterialComponent", "allergenicIndicator", element.getAllergenicIndicatorElement(), -1); 8612 } 8613 } 8614 8615 protected void composeDeviceMetric(Complex parent, String parentType, String name, DeviceMetric element, int index) { 8616 if (element == null) 8617 return; 8618 Complex t; 8619 if (Utilities.noString(parentType)) 8620 t = parent; 8621 else { 8622 t = parent.predicate("fhir:"+parentType+'.'+name); 8623 } 8624 composeDomainResource(t, "DeviceMetric", name, element, index); 8625 for (int i = 0; i < element.getIdentifier().size(); i++) { 8626 composeIdentifier(t, "DeviceMetric", "identifier", element.getIdentifier().get(i), i); 8627 } 8628 if (element.hasType()) { 8629 composeCodeableConcept(t, "DeviceMetric", "type", element.getType(), -1); 8630 } 8631 if (element.hasUnit()) { 8632 composeCodeableConcept(t, "DeviceMetric", "unit", element.getUnit(), -1); 8633 } 8634 if (element.hasSource()) { 8635 composeReference(t, "DeviceMetric", "source", element.getSource(), -1); 8636 } 8637 if (element.hasParent()) { 8638 composeReference(t, "DeviceMetric", "parent", element.getParent(), -1); 8639 } 8640 if (element.hasOperationalStatusElement()) { 8641 composeEnum(t, "DeviceMetric", "operationalStatus", element.getOperationalStatusElement(), -1); 8642 } 8643 if (element.hasColorElement()) { 8644 composeEnum(t, "DeviceMetric", "color", element.getColorElement(), -1); 8645 } 8646 if (element.hasCategoryElement()) { 8647 composeEnum(t, "DeviceMetric", "category", element.getCategoryElement(), -1); 8648 } 8649 if (element.hasMeasurementPeriod()) { 8650 composeTiming(t, "DeviceMetric", "measurementPeriod", element.getMeasurementPeriod(), -1); 8651 } 8652 for (int i = 0; i < element.getCalibration().size(); i++) { 8653 composeDeviceMetricCalibrationComponent(t, "DeviceMetric", "calibration", element.getCalibration().get(i), i); 8654 } 8655 } 8656 8657 protected void composeDeviceMetricCalibrationComponent(Complex parent, String parentType, String name, DeviceMetric.DeviceMetricCalibrationComponent element, int index) { 8658 if (element == null) 8659 return; 8660 Complex t; 8661 if (Utilities.noString(parentType)) 8662 t = parent; 8663 else { 8664 t = parent.predicate("fhir:"+parentType+'.'+name); 8665 } 8666 composeBackboneElement(t, "calibration", name, element, index); 8667 if (element.hasTypeElement()) { 8668 composeEnum(t, "DeviceMetricCalibrationComponent", "type", element.getTypeElement(), -1); 8669 } 8670 if (element.hasStateElement()) { 8671 composeEnum(t, "DeviceMetricCalibrationComponent", "state", element.getStateElement(), -1); 8672 } 8673 if (element.hasTimeElement()) { 8674 composeInstant(t, "DeviceMetricCalibrationComponent", "time", element.getTimeElement(), -1); 8675 } 8676 } 8677 8678 protected void composeDeviceRequest(Complex parent, String parentType, String name, DeviceRequest 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 composeDomainResource(t, "DeviceRequest", name, element, index); 8688 for (int i = 0; i < element.getIdentifier().size(); i++) { 8689 composeIdentifier(t, "DeviceRequest", "identifier", element.getIdentifier().get(i), i); 8690 } 8691 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) { 8692 composeCanonical(t, "DeviceRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 8693 } 8694 for (int i = 0; i < element.getInstantiatesUri().size(); i++) { 8695 composeUri(t, "DeviceRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i); 8696 } 8697 for (int i = 0; i < element.getBasedOn().size(); i++) { 8698 composeReference(t, "DeviceRequest", "basedOn", element.getBasedOn().get(i), i); 8699 } 8700 for (int i = 0; i < element.getPriorRequest().size(); i++) { 8701 composeReference(t, "DeviceRequest", "priorRequest", element.getPriorRequest().get(i), i); 8702 } 8703 if (element.hasGroupIdentifier()) { 8704 composeIdentifier(t, "DeviceRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 8705 } 8706 if (element.hasStatusElement()) { 8707 composeEnum(t, "DeviceRequest", "status", element.getStatusElement(), -1); 8708 } 8709 if (element.hasIntentElement()) { 8710 composeEnum(t, "DeviceRequest", "intent", element.getIntentElement(), -1); 8711 } 8712 if (element.hasPriorityElement()) { 8713 composeEnum(t, "DeviceRequest", "priority", element.getPriorityElement(), -1); 8714 } 8715 if (element.hasCode()) { 8716 composeType(t, "DeviceRequest", "code", element.getCode(), -1); 8717 } 8718 for (int i = 0; i < element.getParameter().size(); i++) { 8719 composeDeviceRequestParameterComponent(t, "DeviceRequest", "parameter", element.getParameter().get(i), i); 8720 } 8721 if (element.hasSubject()) { 8722 composeReference(t, "DeviceRequest", "subject", element.getSubject(), -1); 8723 } 8724 if (element.hasEncounter()) { 8725 composeReference(t, "DeviceRequest", "encounter", element.getEncounter(), -1); 8726 } 8727 if (element.hasOccurrence()) { 8728 composeType(t, "DeviceRequest", "occurrence", element.getOccurrence(), -1); 8729 } 8730 if (element.hasAuthoredOnElement()) { 8731 composeDateTime(t, "DeviceRequest", "authoredOn", element.getAuthoredOnElement(), -1); 8732 } 8733 if (element.hasRequester()) { 8734 composeReference(t, "DeviceRequest", "requester", element.getRequester(), -1); 8735 } 8736 if (element.hasPerformerType()) { 8737 composeCodeableConcept(t, "DeviceRequest", "performerType", element.getPerformerType(), -1); 8738 } 8739 if (element.hasPerformer()) { 8740 composeReference(t, "DeviceRequest", "performer", element.getPerformer(), -1); 8741 } 8742 for (int i = 0; i < element.getReason().size(); i++) { 8743 composeCodeableReference(t, "DeviceRequest", "reason", element.getReason().get(i), i); 8744 } 8745 for (int i = 0; i < element.getInsurance().size(); i++) { 8746 composeReference(t, "DeviceRequest", "insurance", element.getInsurance().get(i), i); 8747 } 8748 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 8749 composeReference(t, "DeviceRequest", "supportingInfo", element.getSupportingInfo().get(i), i); 8750 } 8751 for (int i = 0; i < element.getNote().size(); i++) { 8752 composeAnnotation(t, "DeviceRequest", "note", element.getNote().get(i), i); 8753 } 8754 for (int i = 0; i < element.getRelevantHistory().size(); i++) { 8755 composeReference(t, "DeviceRequest", "relevantHistory", element.getRelevantHistory().get(i), i); 8756 } 8757 } 8758 8759 protected void composeDeviceRequestParameterComponent(Complex parent, String parentType, String name, DeviceRequest.DeviceRequestParameterComponent element, int index) { 8760 if (element == null) 8761 return; 8762 Complex t; 8763 if (Utilities.noString(parentType)) 8764 t = parent; 8765 else { 8766 t = parent.predicate("fhir:"+parentType+'.'+name); 8767 } 8768 composeBackboneElement(t, "parameter", name, element, index); 8769 if (element.hasCode()) { 8770 composeCodeableConcept(t, "DeviceRequestParameterComponent", "code", element.getCode(), -1); 8771 } 8772 if (element.hasValue()) { 8773 composeType(t, "DeviceRequestParameterComponent", "value", element.getValue(), -1); 8774 } 8775 } 8776 8777 protected void composeDeviceUseStatement(Complex parent, String parentType, String name, DeviceUseStatement element, int index) { 8778 if (element == null) 8779 return; 8780 Complex t; 8781 if (Utilities.noString(parentType)) 8782 t = parent; 8783 else { 8784 t = parent.predicate("fhir:"+parentType+'.'+name); 8785 } 8786 composeDomainResource(t, "DeviceUseStatement", name, element, index); 8787 for (int i = 0; i < element.getIdentifier().size(); i++) { 8788 composeIdentifier(t, "DeviceUseStatement", "identifier", element.getIdentifier().get(i), i); 8789 } 8790 for (int i = 0; i < element.getBasedOn().size(); i++) { 8791 composeReference(t, "DeviceUseStatement", "basedOn", element.getBasedOn().get(i), i); 8792 } 8793 if (element.hasStatusElement()) { 8794 composeEnum(t, "DeviceUseStatement", "status", element.getStatusElement(), -1); 8795 } 8796 if (element.hasSubject()) { 8797 composeReference(t, "DeviceUseStatement", "subject", element.getSubject(), -1); 8798 } 8799 for (int i = 0; i < element.getDerivedFrom().size(); i++) { 8800 composeReference(t, "DeviceUseStatement", "derivedFrom", element.getDerivedFrom().get(i), i); 8801 } 8802 if (element.hasTiming()) { 8803 composeType(t, "DeviceUseStatement", "timing", element.getTiming(), -1); 8804 } 8805 if (element.hasRecordedOnElement()) { 8806 composeDateTime(t, "DeviceUseStatement", "recordedOn", element.getRecordedOnElement(), -1); 8807 } 8808 if (element.hasSource()) { 8809 composeReference(t, "DeviceUseStatement", "source", element.getSource(), -1); 8810 } 8811 if (element.hasDevice()) { 8812 composeReference(t, "DeviceUseStatement", "device", element.getDevice(), -1); 8813 } 8814 for (int i = 0; i < element.getReason().size(); i++) { 8815 composeCodeableReference(t, "DeviceUseStatement", "reason", element.getReason().get(i), i); 8816 } 8817 if (element.hasBodySite()) { 8818 composeCodeableConcept(t, "DeviceUseStatement", "bodySite", element.getBodySite(), -1); 8819 } 8820 for (int i = 0; i < element.getNote().size(); i++) { 8821 composeAnnotation(t, "DeviceUseStatement", "note", element.getNote().get(i), i); 8822 } 8823 } 8824 8825 protected void composeDiagnosticReport(Complex parent, String parentType, String name, DiagnosticReport element, int index) { 8826 if (element == null) 8827 return; 8828 Complex t; 8829 if (Utilities.noString(parentType)) 8830 t = parent; 8831 else { 8832 t = parent.predicate("fhir:"+parentType+'.'+name); 8833 } 8834 composeDomainResource(t, "DiagnosticReport", name, element, index); 8835 for (int i = 0; i < element.getIdentifier().size(); i++) { 8836 composeIdentifier(t, "DiagnosticReport", "identifier", element.getIdentifier().get(i), i); 8837 } 8838 for (int i = 0; i < element.getBasedOn().size(); i++) { 8839 composeReference(t, "DiagnosticReport", "basedOn", element.getBasedOn().get(i), i); 8840 } 8841 if (element.hasStatusElement()) { 8842 composeEnum(t, "DiagnosticReport", "status", element.getStatusElement(), -1); 8843 } 8844 for (int i = 0; i < element.getCategory().size(); i++) { 8845 composeCodeableConcept(t, "DiagnosticReport", "category", element.getCategory().get(i), i); 8846 } 8847 if (element.hasCode()) { 8848 composeCodeableConcept(t, "DiagnosticReport", "code", element.getCode(), -1); 8849 } 8850 if (element.hasSubject()) { 8851 composeReference(t, "DiagnosticReport", "subject", element.getSubject(), -1); 8852 } 8853 if (element.hasEncounter()) { 8854 composeReference(t, "DiagnosticReport", "encounter", element.getEncounter(), -1); 8855 } 8856 if (element.hasEffective()) { 8857 composeType(t, "DiagnosticReport", "effective", element.getEffective(), -1); 8858 } 8859 if (element.hasIssuedElement()) { 8860 composeInstant(t, "DiagnosticReport", "issued", element.getIssuedElement(), -1); 8861 } 8862 for (int i = 0; i < element.getPerformer().size(); i++) { 8863 composeReference(t, "DiagnosticReport", "performer", element.getPerformer().get(i), i); 8864 } 8865 for (int i = 0; i < element.getResultsInterpreter().size(); i++) { 8866 composeReference(t, "DiagnosticReport", "resultsInterpreter", element.getResultsInterpreter().get(i), i); 8867 } 8868 for (int i = 0; i < element.getSpecimen().size(); i++) { 8869 composeReference(t, "DiagnosticReport", "specimen", element.getSpecimen().get(i), i); 8870 } 8871 for (int i = 0; i < element.getResult().size(); i++) { 8872 composeReference(t, "DiagnosticReport", "result", element.getResult().get(i), i); 8873 } 8874 for (int i = 0; i < element.getImagingStudy().size(); i++) { 8875 composeReference(t, "DiagnosticReport", "imagingStudy", element.getImagingStudy().get(i), i); 8876 } 8877 for (int i = 0; i < element.getMedia().size(); i++) { 8878 composeDiagnosticReportMediaComponent(t, "DiagnosticReport", "media", element.getMedia().get(i), i); 8879 } 8880 if (element.hasConclusionElement()) { 8881 composeString(t, "DiagnosticReport", "conclusion", element.getConclusionElement(), -1); 8882 } 8883 for (int i = 0; i < element.getConclusionCode().size(); i++) { 8884 composeCodeableConcept(t, "DiagnosticReport", "conclusionCode", element.getConclusionCode().get(i), i); 8885 } 8886 for (int i = 0; i < element.getPresentedForm().size(); i++) { 8887 composeAttachment(t, "DiagnosticReport", "presentedForm", element.getPresentedForm().get(i), i); 8888 } 8889 } 8890 8891 protected void composeDiagnosticReportMediaComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportMediaComponent element, int index) { 8892 if (element == null) 8893 return; 8894 Complex t; 8895 if (Utilities.noString(parentType)) 8896 t = parent; 8897 else { 8898 t = parent.predicate("fhir:"+parentType+'.'+name); 8899 } 8900 composeBackboneElement(t, "media", name, element, index); 8901 if (element.hasCommentElement()) { 8902 composeString(t, "DiagnosticReportMediaComponent", "comment", element.getCommentElement(), -1); 8903 } 8904 if (element.hasLink()) { 8905 composeReference(t, "DiagnosticReportMediaComponent", "link", element.getLink(), -1); 8906 } 8907 } 8908 8909 protected void composeDocumentManifest(Complex parent, String parentType, String name, DocumentManifest element, int index) { 8910 if (element == null) 8911 return; 8912 Complex t; 8913 if (Utilities.noString(parentType)) 8914 t = parent; 8915 else { 8916 t = parent.predicate("fhir:"+parentType+'.'+name); 8917 } 8918 composeDomainResource(t, "DocumentManifest", name, element, index); 8919 if (element.hasMasterIdentifier()) { 8920 composeIdentifier(t, "DocumentManifest", "masterIdentifier", element.getMasterIdentifier(), -1); 8921 } 8922 for (int i = 0; i < element.getIdentifier().size(); i++) { 8923 composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier().get(i), i); 8924 } 8925 if (element.hasStatusElement()) { 8926 composeEnum(t, "DocumentManifest", "status", element.getStatusElement(), -1); 8927 } 8928 if (element.hasType()) { 8929 composeCodeableConcept(t, "DocumentManifest", "type", element.getType(), -1); 8930 } 8931 if (element.hasSubject()) { 8932 composeReference(t, "DocumentManifest", "subject", element.getSubject(), -1); 8933 } 8934 if (element.hasCreatedElement()) { 8935 composeDateTime(t, "DocumentManifest", "created", element.getCreatedElement(), -1); 8936 } 8937 for (int i = 0; i < element.getAuthor().size(); i++) { 8938 composeReference(t, "DocumentManifest", "author", element.getAuthor().get(i), i); 8939 } 8940 for (int i = 0; i < element.getRecipient().size(); i++) { 8941 composeReference(t, "DocumentManifest", "recipient", element.getRecipient().get(i), i); 8942 } 8943 if (element.hasSourceElement()) { 8944 composeUri(t, "DocumentManifest", "source", element.getSourceElement(), -1); 8945 } 8946 if (element.hasDescriptionElement()) { 8947 composeString(t, "DocumentManifest", "description", element.getDescriptionElement(), -1); 8948 } 8949 for (int i = 0; i < element.getContent().size(); i++) { 8950 composeReference(t, "DocumentManifest", "content", element.getContent().get(i), i); 8951 } 8952 for (int i = 0; i < element.getRelated().size(); i++) { 8953 composeDocumentManifestRelatedComponent(t, "DocumentManifest", "related", element.getRelated().get(i), i); 8954 } 8955 } 8956 8957 protected void composeDocumentManifestRelatedComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestRelatedComponent element, int index) { 8958 if (element == null) 8959 return; 8960 Complex t; 8961 if (Utilities.noString(parentType)) 8962 t = parent; 8963 else { 8964 t = parent.predicate("fhir:"+parentType+'.'+name); 8965 } 8966 composeBackboneElement(t, "related", name, element, index); 8967 if (element.hasIdentifier()) { 8968 composeIdentifier(t, "DocumentManifestRelatedComponent", "identifier", element.getIdentifier(), -1); 8969 } 8970 if (element.hasRef()) { 8971 composeReference(t, "DocumentManifestRelatedComponent", "ref", element.getRef(), -1); 8972 } 8973 } 8974 8975 protected void composeDocumentReference(Complex parent, String parentType, String name, DocumentReference element, int index) { 8976 if (element == null) 8977 return; 8978 Complex t; 8979 if (Utilities.noString(parentType)) 8980 t = parent; 8981 else { 8982 t = parent.predicate("fhir:"+parentType+'.'+name); 8983 } 8984 composeDomainResource(t, "DocumentReference", name, element, index); 8985 if (element.hasMasterIdentifier()) { 8986 composeIdentifier(t, "DocumentReference", "masterIdentifier", element.getMasterIdentifier(), -1); 8987 } 8988 for (int i = 0; i < element.getIdentifier().size(); i++) { 8989 composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier().get(i), i); 8990 } 8991 if (element.hasStatusElement()) { 8992 composeEnum(t, "DocumentReference", "status", element.getStatusElement(), -1); 8993 } 8994 if (element.hasDocStatusElement()) { 8995 composeEnum(t, "DocumentReference", "docStatus", element.getDocStatusElement(), -1); 8996 } 8997 if (element.hasType()) { 8998 composeCodeableConcept(t, "DocumentReference", "type", element.getType(), -1); 8999 } 9000 for (int i = 0; i < element.getCategory().size(); i++) { 9001 composeCodeableConcept(t, "DocumentReference", "category", element.getCategory().get(i), i); 9002 } 9003 if (element.hasSubject()) { 9004 composeReference(t, "DocumentReference", "subject", element.getSubject(), -1); 9005 } 9006 if (element.hasDateElement()) { 9007 composeInstant(t, "DocumentReference", "date", element.getDateElement(), -1); 9008 } 9009 for (int i = 0; i < element.getAuthor().size(); i++) { 9010 composeReference(t, "DocumentReference", "author", element.getAuthor().get(i), i); 9011 } 9012 if (element.hasAuthenticator()) { 9013 composeReference(t, "DocumentReference", "authenticator", element.getAuthenticator(), -1); 9014 } 9015 if (element.hasCustodian()) { 9016 composeReference(t, "DocumentReference", "custodian", element.getCustodian(), -1); 9017 } 9018 for (int i = 0; i < element.getRelatesTo().size(); i++) { 9019 composeDocumentReferenceRelatesToComponent(t, "DocumentReference", "relatesTo", element.getRelatesTo().get(i), i); 9020 } 9021 if (element.hasDescriptionElement()) { 9022 composeString(t, "DocumentReference", "description", element.getDescriptionElement(), -1); 9023 } 9024 for (int i = 0; i < element.getSecurityLabel().size(); i++) { 9025 composeCodeableConcept(t, "DocumentReference", "securityLabel", element.getSecurityLabel().get(i), i); 9026 } 9027 for (int i = 0; i < element.getContent().size(); i++) { 9028 composeDocumentReferenceContentComponent(t, "DocumentReference", "content", element.getContent().get(i), i); 9029 } 9030 if (element.hasContext()) { 9031 composeDocumentReferenceContextComponent(t, "DocumentReference", "context", element.getContext(), -1); 9032 } 9033 } 9034 9035 protected void composeDocumentReferenceRelatesToComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceRelatesToComponent element, int index) { 9036 if (element == null) 9037 return; 9038 Complex t; 9039 if (Utilities.noString(parentType)) 9040 t = parent; 9041 else { 9042 t = parent.predicate("fhir:"+parentType+'.'+name); 9043 } 9044 composeBackboneElement(t, "relatesTo", name, element, index); 9045 if (element.hasCodeElement()) { 9046 composeEnum(t, "DocumentReferenceRelatesToComponent", "code", element.getCodeElement(), -1); 9047 } 9048 if (element.hasTarget()) { 9049 composeReference(t, "DocumentReferenceRelatesToComponent", "target", element.getTarget(), -1); 9050 } 9051 } 9052 9053 protected void composeDocumentReferenceContentComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContentComponent element, int index) { 9054 if (element == null) 9055 return; 9056 Complex t; 9057 if (Utilities.noString(parentType)) 9058 t = parent; 9059 else { 9060 t = parent.predicate("fhir:"+parentType+'.'+name); 9061 } 9062 composeBackboneElement(t, "content", name, element, index); 9063 if (element.hasAttachment()) { 9064 composeAttachment(t, "DocumentReferenceContentComponent", "attachment", element.getAttachment(), -1); 9065 } 9066 if (element.hasFormat()) { 9067 composeCoding(t, "DocumentReferenceContentComponent", "format", element.getFormat(), -1); 9068 } 9069 } 9070 9071 protected void composeDocumentReferenceContextComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextComponent element, int index) { 9072 if (element == null) 9073 return; 9074 Complex t; 9075 if (Utilities.noString(parentType)) 9076 t = parent; 9077 else { 9078 t = parent.predicate("fhir:"+parentType+'.'+name); 9079 } 9080 composeBackboneElement(t, "context", name, element, index); 9081 for (int i = 0; i < element.getEncounter().size(); i++) { 9082 composeReference(t, "DocumentReferenceContextComponent", "encounter", element.getEncounter().get(i), i); 9083 } 9084 for (int i = 0; i < element.getEvent().size(); i++) { 9085 composeCodeableConcept(t, "DocumentReferenceContextComponent", "event", element.getEvent().get(i), i); 9086 } 9087 if (element.hasPeriod()) { 9088 composePeriod(t, "DocumentReferenceContextComponent", "period", element.getPeriod(), -1); 9089 } 9090 if (element.hasFacilityType()) { 9091 composeCodeableConcept(t, "DocumentReferenceContextComponent", "facilityType", element.getFacilityType(), -1); 9092 } 9093 if (element.hasPracticeSetting()) { 9094 composeCodeableConcept(t, "DocumentReferenceContextComponent", "practiceSetting", element.getPracticeSetting(), -1); 9095 } 9096 if (element.hasSourcePatientInfo()) { 9097 composeReference(t, "DocumentReferenceContextComponent", "sourcePatientInfo", element.getSourcePatientInfo(), -1); 9098 } 9099 for (int i = 0; i < element.getRelated().size(); i++) { 9100 composeReference(t, "DocumentReferenceContextComponent", "related", element.getRelated().get(i), i); 9101 } 9102 for (int i = 0; i < element.getBasedOn().size(); i++) { 9103 composeReference(t, "DocumentReferenceContextComponent", "basedOn", element.getBasedOn().get(i), i); 9104 } 9105 } 9106 9107 protected void composeEncounter(Complex parent, String parentType, String name, Encounter element, int index) { 9108 if (element == null) 9109 return; 9110 Complex t; 9111 if (Utilities.noString(parentType)) 9112 t = parent; 9113 else { 9114 t = parent.predicate("fhir:"+parentType+'.'+name); 9115 } 9116 composeDomainResource(t, "Encounter", name, element, index); 9117 for (int i = 0; i < element.getIdentifier().size(); i++) { 9118 composeIdentifier(t, "Encounter", "identifier", element.getIdentifier().get(i), i); 9119 } 9120 if (element.hasStatusElement()) { 9121 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 9122 } 9123 for (int i = 0; i < element.getStatusHistory().size(); i++) { 9124 composeEncounterStatusHistoryComponent(t, "Encounter", "statusHistory", element.getStatusHistory().get(i), i); 9125 } 9126 if (element.hasClass_()) { 9127 composeCoding(t, "Encounter", "class", element.getClass_(), -1); 9128 } 9129 for (int i = 0; i < element.getClassHistory().size(); i++) { 9130 composeEncounterClassHistoryComponent(t, "Encounter", "classHistory", element.getClassHistory().get(i), i); 9131 } 9132 for (int i = 0; i < element.getType().size(); i++) { 9133 composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i); 9134 } 9135 if (element.hasServiceType()) { 9136 composeCodeableConcept(t, "Encounter", "serviceType", element.getServiceType(), -1); 9137 } 9138 if (element.hasPriority()) { 9139 composeCodeableConcept(t, "Encounter", "priority", element.getPriority(), -1); 9140 } 9141 if (element.hasSubject()) { 9142 composeReference(t, "Encounter", "subject", element.getSubject(), -1); 9143 } 9144 if (element.hasSubjectStatus()) { 9145 composeCodeableConcept(t, "Encounter", "subjectStatus", element.getSubjectStatus(), -1); 9146 } 9147 for (int i = 0; i < element.getEpisodeOfCare().size(); i++) { 9148 composeReference(t, "Encounter", "episodeOfCare", element.getEpisodeOfCare().get(i), i); 9149 } 9150 for (int i = 0; i < element.getBasedOn().size(); i++) { 9151 composeReference(t, "Encounter", "basedOn", element.getBasedOn().get(i), i); 9152 } 9153 for (int i = 0; i < element.getParticipant().size(); i++) { 9154 composeEncounterParticipantComponent(t, "Encounter", "participant", element.getParticipant().get(i), i); 9155 } 9156 for (int i = 0; i < element.getAppointment().size(); i++) { 9157 composeReference(t, "Encounter", "appointment", element.getAppointment().get(i), i); 9158 } 9159 if (element.hasPeriod()) { 9160 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 9161 } 9162 if (element.hasLength()) { 9163 composeDuration(t, "Encounter", "length", element.getLength(), -1); 9164 } 9165 for (int i = 0; i < element.getReason().size(); i++) { 9166 composeCodeableReference(t, "Encounter", "reason", element.getReason().get(i), i); 9167 } 9168 for (int i = 0; i < element.getDiagnosis().size(); i++) { 9169 composeEncounterDiagnosisComponent(t, "Encounter", "diagnosis", element.getDiagnosis().get(i), i); 9170 } 9171 for (int i = 0; i < element.getAccount().size(); i++) { 9172 composeReference(t, "Encounter", "account", element.getAccount().get(i), i); 9173 } 9174 if (element.hasHospitalization()) { 9175 composeEncounterHospitalizationComponent(t, "Encounter", "hospitalization", element.getHospitalization(), -1); 9176 } 9177 for (int i = 0; i < element.getLocation().size(); i++) { 9178 composeEncounterLocationComponent(t, "Encounter", "location", element.getLocation().get(i), i); 9179 } 9180 if (element.hasServiceProvider()) { 9181 composeReference(t, "Encounter", "serviceProvider", element.getServiceProvider(), -1); 9182 } 9183 if (element.hasPartOf()) { 9184 composeReference(t, "Encounter", "partOf", element.getPartOf(), -1); 9185 } 9186 } 9187 9188 protected void composeEncounterStatusHistoryComponent(Complex parent, String parentType, String name, Encounter.StatusHistoryComponent 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, "statusHistory", name, element, index); 9198 if (element.hasStatusElement()) { 9199 composeEnum(t, "StatusHistoryComponent", "status", element.getStatusElement(), -1); 9200 } 9201 if (element.hasPeriod()) { 9202 composePeriod(t, "StatusHistoryComponent", "period", element.getPeriod(), -1); 9203 } 9204 } 9205 9206 protected void composeEncounterClassHistoryComponent(Complex parent, String parentType, String name, Encounter.ClassHistoryComponent 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, "classHistory", name, element, index); 9216 if (element.hasClass_()) { 9217 composeCoding(t, "ClassHistoryComponent", "class", element.getClass_(), -1); 9218 } 9219 if (element.hasPeriod()) { 9220 composePeriod(t, "ClassHistoryComponent", "period", element.getPeriod(), -1); 9221 } 9222 } 9223 9224 protected void composeEncounterParticipantComponent(Complex parent, String parentType, String name, Encounter.EncounterParticipantComponent element, int index) { 9225 if (element == null) 9226 return; 9227 Complex t; 9228 if (Utilities.noString(parentType)) 9229 t = parent; 9230 else { 9231 t = parent.predicate("fhir:"+parentType+'.'+name); 9232 } 9233 composeBackboneElement(t, "participant", name, element, index); 9234 for (int i = 0; i < element.getType().size(); i++) { 9235 composeCodeableConcept(t, "EncounterParticipantComponent", "type", element.getType().get(i), i); 9236 } 9237 if (element.hasPeriod()) { 9238 composePeriod(t, "EncounterParticipantComponent", "period", element.getPeriod(), -1); 9239 } 9240 if (element.hasIndividual()) { 9241 composeReference(t, "EncounterParticipantComponent", "individual", element.getIndividual(), -1); 9242 } 9243 } 9244 9245 protected void composeEncounterDiagnosisComponent(Complex parent, String parentType, String name, Encounter.DiagnosisComponent element, int index) { 9246 if (element == null) 9247 return; 9248 Complex t; 9249 if (Utilities.noString(parentType)) 9250 t = parent; 9251 else { 9252 t = parent.predicate("fhir:"+parentType+'.'+name); 9253 } 9254 composeBackboneElement(t, "diagnosis", name, element, index); 9255 if (element.hasCondition()) { 9256 composeReference(t, "DiagnosisComponent", "condition", element.getCondition(), -1); 9257 } 9258 if (element.hasUse()) { 9259 composeCodeableConcept(t, "DiagnosisComponent", "use", element.getUse(), -1); 9260 } 9261 if (element.hasRankElement()) { 9262 composePositiveInt(t, "DiagnosisComponent", "rank", element.getRankElement(), -1); 9263 } 9264 } 9265 9266 protected void composeEncounterHospitalizationComponent(Complex parent, String parentType, String name, Encounter.EncounterHospitalizationComponent 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, "hospitalization", name, element, index); 9276 if (element.hasPreAdmissionIdentifier()) { 9277 composeIdentifier(t, "EncounterHospitalizationComponent", "preAdmissionIdentifier", element.getPreAdmissionIdentifier(), -1); 9278 } 9279 if (element.hasOrigin()) { 9280 composeReference(t, "EncounterHospitalizationComponent", "origin", element.getOrigin(), -1); 9281 } 9282 if (element.hasAdmitSource()) { 9283 composeCodeableConcept(t, "EncounterHospitalizationComponent", "admitSource", element.getAdmitSource(), -1); 9284 } 9285 if (element.hasReAdmission()) { 9286 composeCodeableConcept(t, "EncounterHospitalizationComponent", "reAdmission", element.getReAdmission(), -1); 9287 } 9288 for (int i = 0; i < element.getDietPreference().size(); i++) { 9289 composeCodeableConcept(t, "EncounterHospitalizationComponent", "dietPreference", element.getDietPreference().get(i), i); 9290 } 9291 for (int i = 0; i < element.getSpecialCourtesy().size(); i++) { 9292 composeCodeableConcept(t, "EncounterHospitalizationComponent", "specialCourtesy", element.getSpecialCourtesy().get(i), i); 9293 } 9294 for (int i = 0; i < element.getSpecialArrangement().size(); i++) { 9295 composeCodeableConcept(t, "EncounterHospitalizationComponent", "specialArrangement", element.getSpecialArrangement().get(i), i); 9296 } 9297 if (element.hasDestination()) { 9298 composeReference(t, "EncounterHospitalizationComponent", "destination", element.getDestination(), -1); 9299 } 9300 if (element.hasDischargeDisposition()) { 9301 composeCodeableConcept(t, "EncounterHospitalizationComponent", "dischargeDisposition", element.getDischargeDisposition(), -1); 9302 } 9303 } 9304 9305 protected void composeEncounterLocationComponent(Complex parent, String parentType, String name, Encounter.EncounterLocationComponent element, int index) { 9306 if (element == null) 9307 return; 9308 Complex t; 9309 if (Utilities.noString(parentType)) 9310 t = parent; 9311 else { 9312 t = parent.predicate("fhir:"+parentType+'.'+name); 9313 } 9314 composeBackboneElement(t, "location", name, element, index); 9315 if (element.hasLocation()) { 9316 composeReference(t, "EncounterLocationComponent", "location", element.getLocation(), -1); 9317 } 9318 if (element.hasStatusElement()) { 9319 composeEnum(t, "EncounterLocationComponent", "status", element.getStatusElement(), -1); 9320 } 9321 if (element.hasPhysicalType()) { 9322 composeCodeableConcept(t, "EncounterLocationComponent", "physicalType", element.getPhysicalType(), -1); 9323 } 9324 if (element.hasPeriod()) { 9325 composePeriod(t, "EncounterLocationComponent", "period", element.getPeriod(), -1); 9326 } 9327 } 9328 9329 protected void composeEndpoint(Complex parent, String parentType, String name, Endpoint element, int index) { 9330 if (element == null) 9331 return; 9332 Complex t; 9333 if (Utilities.noString(parentType)) 9334 t = parent; 9335 else { 9336 t = parent.predicate("fhir:"+parentType+'.'+name); 9337 } 9338 composeDomainResource(t, "Endpoint", name, element, index); 9339 for (int i = 0; i < element.getIdentifier().size(); i++) { 9340 composeIdentifier(t, "Endpoint", "identifier", element.getIdentifier().get(i), i); 9341 } 9342 if (element.hasStatusElement()) { 9343 composeEnum(t, "Endpoint", "status", element.getStatusElement(), -1); 9344 } 9345 if (element.hasConnectionType()) { 9346 composeCoding(t, "Endpoint", "connectionType", element.getConnectionType(), -1); 9347 } 9348 if (element.hasNameElement()) { 9349 composeString(t, "Endpoint", "name", element.getNameElement(), -1); 9350 } 9351 if (element.hasManagingOrganization()) { 9352 composeReference(t, "Endpoint", "managingOrganization", element.getManagingOrganization(), -1); 9353 } 9354 for (int i = 0; i < element.getContact().size(); i++) { 9355 composeContactPoint(t, "Endpoint", "contact", element.getContact().get(i), i); 9356 } 9357 if (element.hasPeriod()) { 9358 composePeriod(t, "Endpoint", "period", element.getPeriod(), -1); 9359 } 9360 for (int i = 0; i < element.getPayloadType().size(); i++) { 9361 composeCodeableConcept(t, "Endpoint", "payloadType", element.getPayloadType().get(i), i); 9362 } 9363 for (int i = 0; i < element.getPayloadMimeType().size(); i++) { 9364 composeCode(t, "Endpoint", "payloadMimeType", element.getPayloadMimeType().get(i), i); 9365 } 9366 if (element.hasAddressElement()) { 9367 composeUrl(t, "Endpoint", "address", element.getAddressElement(), -1); 9368 } 9369 for (int i = 0; i < element.getHeader().size(); i++) { 9370 composeString(t, "Endpoint", "header", element.getHeader().get(i), i); 9371 } 9372 } 9373 9374 protected void composeEnrollmentRequest(Complex parent, String parentType, String name, EnrollmentRequest element, int index) { 9375 if (element == null) 9376 return; 9377 Complex t; 9378 if (Utilities.noString(parentType)) 9379 t = parent; 9380 else { 9381 t = parent.predicate("fhir:"+parentType+'.'+name); 9382 } 9383 composeDomainResource(t, "EnrollmentRequest", name, element, index); 9384 for (int i = 0; i < element.getIdentifier().size(); i++) { 9385 composeIdentifier(t, "EnrollmentRequest", "identifier", element.getIdentifier().get(i), i); 9386 } 9387 if (element.hasStatusElement()) { 9388 composeEnum(t, "EnrollmentRequest", "status", element.getStatusElement(), -1); 9389 } 9390 if (element.hasCreatedElement()) { 9391 composeDateTime(t, "EnrollmentRequest", "created", element.getCreatedElement(), -1); 9392 } 9393 if (element.hasInsurer()) { 9394 composeReference(t, "EnrollmentRequest", "insurer", element.getInsurer(), -1); 9395 } 9396 if (element.hasProvider()) { 9397 composeReference(t, "EnrollmentRequest", "provider", element.getProvider(), -1); 9398 } 9399 if (element.hasCandidate()) { 9400 composeReference(t, "EnrollmentRequest", "candidate", element.getCandidate(), -1); 9401 } 9402 if (element.hasCoverage()) { 9403 composeReference(t, "EnrollmentRequest", "coverage", element.getCoverage(), -1); 9404 } 9405 } 9406 9407 protected void composeEnrollmentResponse(Complex parent, String parentType, String name, EnrollmentResponse element, int index) { 9408 if (element == null) 9409 return; 9410 Complex t; 9411 if (Utilities.noString(parentType)) 9412 t = parent; 9413 else { 9414 t = parent.predicate("fhir:"+parentType+'.'+name); 9415 } 9416 composeDomainResource(t, "EnrollmentResponse", name, element, index); 9417 for (int i = 0; i < element.getIdentifier().size(); i++) { 9418 composeIdentifier(t, "EnrollmentResponse", "identifier", element.getIdentifier().get(i), i); 9419 } 9420 if (element.hasStatusElement()) { 9421 composeEnum(t, "EnrollmentResponse", "status", element.getStatusElement(), -1); 9422 } 9423 if (element.hasRequest()) { 9424 composeReference(t, "EnrollmentResponse", "request", element.getRequest(), -1); 9425 } 9426 if (element.hasOutcomeElement()) { 9427 composeEnum(t, "EnrollmentResponse", "outcome", element.getOutcomeElement(), -1); 9428 } 9429 if (element.hasDispositionElement()) { 9430 composeString(t, "EnrollmentResponse", "disposition", element.getDispositionElement(), -1); 9431 } 9432 if (element.hasCreatedElement()) { 9433 composeDateTime(t, "EnrollmentResponse", "created", element.getCreatedElement(), -1); 9434 } 9435 if (element.hasOrganization()) { 9436 composeReference(t, "EnrollmentResponse", "organization", element.getOrganization(), -1); 9437 } 9438 if (element.hasRequestProvider()) { 9439 composeReference(t, "EnrollmentResponse", "requestProvider", element.getRequestProvider(), -1); 9440 } 9441 } 9442 9443 protected void composeEpisodeOfCare(Complex parent, String parentType, String name, EpisodeOfCare element, int index) { 9444 if (element == null) 9445 return; 9446 Complex t; 9447 if (Utilities.noString(parentType)) 9448 t = parent; 9449 else { 9450 t = parent.predicate("fhir:"+parentType+'.'+name); 9451 } 9452 composeDomainResource(t, "EpisodeOfCare", name, element, index); 9453 for (int i = 0; i < element.getIdentifier().size(); i++) { 9454 composeIdentifier(t, "EpisodeOfCare", "identifier", element.getIdentifier().get(i), i); 9455 } 9456 if (element.hasStatusElement()) { 9457 composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1); 9458 } 9459 for (int i = 0; i < element.getStatusHistory().size(); i++) { 9460 composeEpisodeOfCareStatusHistoryComponent(t, "EpisodeOfCare", "statusHistory", element.getStatusHistory().get(i), i); 9461 } 9462 for (int i = 0; i < element.getType().size(); i++) { 9463 composeCodeableConcept(t, "EpisodeOfCare", "type", element.getType().get(i), i); 9464 } 9465 for (int i = 0; i < element.getDiagnosis().size(); i++) { 9466 composeEpisodeOfCareDiagnosisComponent(t, "EpisodeOfCare", "diagnosis", element.getDiagnosis().get(i), i); 9467 } 9468 if (element.hasPatient()) { 9469 composeReference(t, "EpisodeOfCare", "patient", element.getPatient(), -1); 9470 } 9471 if (element.hasManagingOrganization()) { 9472 composeReference(t, "EpisodeOfCare", "managingOrganization", element.getManagingOrganization(), -1); 9473 } 9474 if (element.hasPeriod()) { 9475 composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1); 9476 } 9477 for (int i = 0; i < element.getReferralRequest().size(); i++) { 9478 composeReference(t, "EpisodeOfCare", "referralRequest", element.getReferralRequest().get(i), i); 9479 } 9480 if (element.hasCareManager()) { 9481 composeReference(t, "EpisodeOfCare", "careManager", element.getCareManager(), -1); 9482 } 9483 for (int i = 0; i < element.getTeam().size(); i++) { 9484 composeReference(t, "EpisodeOfCare", "team", element.getTeam().get(i), i); 9485 } 9486 for (int i = 0; i < element.getAccount().size(); i++) { 9487 composeReference(t, "EpisodeOfCare", "account", element.getAccount().get(i), i); 9488 } 9489 } 9490 9491 protected void composeEpisodeOfCareStatusHistoryComponent(Complex parent, String parentType, String name, EpisodeOfCare.EpisodeOfCareStatusHistoryComponent element, int index) { 9492 if (element == null) 9493 return; 9494 Complex t; 9495 if (Utilities.noString(parentType)) 9496 t = parent; 9497 else { 9498 t = parent.predicate("fhir:"+parentType+'.'+name); 9499 } 9500 composeBackboneElement(t, "statusHistory", name, element, index); 9501 if (element.hasStatusElement()) { 9502 composeEnum(t, "EpisodeOfCareStatusHistoryComponent", "status", element.getStatusElement(), -1); 9503 } 9504 if (element.hasPeriod()) { 9505 composePeriod(t, "EpisodeOfCareStatusHistoryComponent", "period", element.getPeriod(), -1); 9506 } 9507 } 9508 9509 protected void composeEpisodeOfCareDiagnosisComponent(Complex parent, String parentType, String name, EpisodeOfCare.DiagnosisComponent element, int index) { 9510 if (element == null) 9511 return; 9512 Complex t; 9513 if (Utilities.noString(parentType)) 9514 t = parent; 9515 else { 9516 t = parent.predicate("fhir:"+parentType+'.'+name); 9517 } 9518 composeBackboneElement(t, "diagnosis", name, element, index); 9519 if (element.hasCondition()) { 9520 composeReference(t, "DiagnosisComponent", "condition", element.getCondition(), -1); 9521 } 9522 if (element.hasRole()) { 9523 composeCodeableConcept(t, "DiagnosisComponent", "role", element.getRole(), -1); 9524 } 9525 if (element.hasRankElement()) { 9526 composePositiveInt(t, "DiagnosisComponent", "rank", element.getRankElement(), -1); 9527 } 9528 } 9529 9530 protected void composeEventDefinition(Complex parent, String parentType, String name, EventDefinition element, int index) { 9531 if (element == null) 9532 return; 9533 Complex t; 9534 if (Utilities.noString(parentType)) 9535 t = parent; 9536 else { 9537 t = parent.predicate("fhir:"+parentType+'.'+name); 9538 } 9539 composeMetadataResource(t, "EventDefinition", name, element, index); 9540 if (element.hasUrlElement()) { 9541 composeUri(t, "EventDefinition", "url", element.getUrlElement(), -1); 9542 } 9543 for (int i = 0; i < element.getIdentifier().size(); i++) { 9544 composeIdentifier(t, "EventDefinition", "identifier", element.getIdentifier().get(i), i); 9545 } 9546 if (element.hasVersionElement()) { 9547 composeString(t, "EventDefinition", "version", element.getVersionElement(), -1); 9548 } 9549 if (element.hasNameElement()) { 9550 composeString(t, "EventDefinition", "name", element.getNameElement(), -1); 9551 } 9552 if (element.hasTitleElement()) { 9553 composeString(t, "EventDefinition", "title", element.getTitleElement(), -1); 9554 } 9555 if (element.hasSubtitleElement()) { 9556 composeString(t, "EventDefinition", "subtitle", element.getSubtitleElement(), -1); 9557 } 9558 if (element.hasStatusElement()) { 9559 composeEnum(t, "EventDefinition", "status", element.getStatusElement(), -1); 9560 } 9561 if (element.hasExperimentalElement()) { 9562 composeBoolean(t, "EventDefinition", "experimental", element.getExperimentalElement(), -1); 9563 } 9564 if (element.hasSubject()) { 9565 composeType(t, "EventDefinition", "subject", element.getSubject(), -1); 9566 } 9567 if (element.hasDateElement()) { 9568 composeDateTime(t, "EventDefinition", "date", element.getDateElement(), -1); 9569 } 9570 if (element.hasPublisherElement()) { 9571 composeString(t, "EventDefinition", "publisher", element.getPublisherElement(), -1); 9572 } 9573 for (int i = 0; i < element.getContact().size(); i++) { 9574 composeContactDetail(t, "EventDefinition", "contact", element.getContact().get(i), i); 9575 } 9576 if (element.hasDescriptionElement()) { 9577 composeMarkdown(t, "EventDefinition", "description", element.getDescriptionElement(), -1); 9578 } 9579 for (int i = 0; i < element.getUseContext().size(); i++) { 9580 composeUsageContext(t, "EventDefinition", "useContext", element.getUseContext().get(i), i); 9581 } 9582 for (int i = 0; i < element.getJurisdiction().size(); i++) { 9583 composeCodeableConcept(t, "EventDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 9584 } 9585 if (element.hasPurposeElement()) { 9586 composeMarkdown(t, "EventDefinition", "purpose", element.getPurposeElement(), -1); 9587 } 9588 if (element.hasUsageElement()) { 9589 composeString(t, "EventDefinition", "usage", element.getUsageElement(), -1); 9590 } 9591 if (element.hasCopyrightElement()) { 9592 composeMarkdown(t, "EventDefinition", "copyright", element.getCopyrightElement(), -1); 9593 } 9594 if (element.hasApprovalDateElement()) { 9595 composeDate(t, "EventDefinition", "approvalDate", element.getApprovalDateElement(), -1); 9596 } 9597 if (element.hasLastReviewDateElement()) { 9598 composeDate(t, "EventDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 9599 } 9600 if (element.hasEffectivePeriod()) { 9601 composePeriod(t, "EventDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 9602 } 9603 for (int i = 0; i < element.getTopic().size(); i++) { 9604 composeCodeableConcept(t, "EventDefinition", "topic", element.getTopic().get(i), i); 9605 } 9606 for (int i = 0; i < element.getAuthor().size(); i++) { 9607 composeContactDetail(t, "EventDefinition", "author", element.getAuthor().get(i), i); 9608 } 9609 for (int i = 0; i < element.getEditor().size(); i++) { 9610 composeContactDetail(t, "EventDefinition", "editor", element.getEditor().get(i), i); 9611 } 9612 for (int i = 0; i < element.getReviewer().size(); i++) { 9613 composeContactDetail(t, "EventDefinition", "reviewer", element.getReviewer().get(i), i); 9614 } 9615 for (int i = 0; i < element.getEndorser().size(); i++) { 9616 composeContactDetail(t, "EventDefinition", "endorser", element.getEndorser().get(i), i); 9617 } 9618 for (int i = 0; i < element.getRelatedArtifact().size(); i++) { 9619 composeRelatedArtifact(t, "EventDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 9620 } 9621 for (int i = 0; i < element.getTrigger().size(); i++) { 9622 composeTriggerDefinition(t, "EventDefinition", "trigger", element.getTrigger().get(i), i); 9623 } 9624 } 9625 9626 protected void composeEvidence(Complex parent, String parentType, String name, Evidence element, int index) { 9627 if (element == null) 9628 return; 9629 Complex t; 9630 if (Utilities.noString(parentType)) 9631 t = parent; 9632 else { 9633 t = parent.predicate("fhir:"+parentType+'.'+name); 9634 } 9635 composeMetadataResource(t, "Evidence", name, element, index); 9636 if (element.hasUrlElement()) { 9637 composeUri(t, "Evidence", "url", element.getUrlElement(), -1); 9638 } 9639 for (int i = 0; i < element.getIdentifier().size(); i++) { 9640 composeIdentifier(t, "Evidence", "identifier", element.getIdentifier().get(i), i); 9641 } 9642 if (element.hasVersionElement()) { 9643 composeString(t, "Evidence", "version", element.getVersionElement(), -1); 9644 } 9645 if (element.hasTitleElement()) { 9646 composeString(t, "Evidence", "title", element.getTitleElement(), -1); 9647 } 9648 if (element.hasStatusElement()) { 9649 composeEnum(t, "Evidence", "status", element.getStatusElement(), -1); 9650 } 9651 if (element.hasDateElement()) { 9652 composeDateTime(t, "Evidence", "date", element.getDateElement(), -1); 9653 } 9654 for (int i = 0; i < element.getUseContext().size(); i++) { 9655 composeUsageContext(t, "Evidence", "useContext", element.getUseContext().get(i), i); 9656 } 9657 if (element.hasApprovalDateElement()) { 9658 composeDate(t, "Evidence", "approvalDate", element.getApprovalDateElement(), -1); 9659 } 9660 if (element.hasLastReviewDateElement()) { 9661 composeDate(t, "Evidence", "lastReviewDate", element.getLastReviewDateElement(), -1); 9662 } 9663 for (int i = 0; i < element.getContributor().size(); i++) { 9664 composeContributor(t, "Evidence", "contributor", element.getContributor().get(i), i); 9665 } 9666 for (int i = 0; i < element.getRelatedArtifact().size(); i++) { 9667 composeRelatedArtifact(t, "Evidence", "relatedArtifact", element.getRelatedArtifact().get(i), i); 9668 } 9669 if (element.hasDescriptionElement()) { 9670 composeMarkdown(t, "Evidence", "description", element.getDescriptionElement(), -1); 9671 } 9672 if (element.hasAssertionElement()) { 9673 composeMarkdown(t, "Evidence", "assertion", element.getAssertionElement(), -1); 9674 } 9675 for (int i = 0; i < element.getNote().size(); i++) { 9676 composeAnnotation(t, "Evidence", "note", element.getNote().get(i), i); 9677 } 9678 if (element.hasReferentGroup()) { 9679 composeEvidenceReferentGroupComponent(t, "Evidence", "referentGroup", element.getReferentGroup(), -1); 9680 } 9681 for (int i = 0; i < element.getVariableDefinition().size(); i++) { 9682 composeEvidenceVariableDefinitionComponent(t, "Evidence", "variableDefinition", element.getVariableDefinition().get(i), i); 9683 } 9684 if (element.hasSynthesisType()) { 9685 composeCodeableConcept(t, "Evidence", "synthesisType", element.getSynthesisType(), -1); 9686 } 9687 if (element.hasStudyType()) { 9688 composeCodeableConcept(t, "Evidence", "studyType", element.getStudyType(), -1); 9689 } 9690 for (int i = 0; i < element.getStatistic().size(); i++) { 9691 composeStatistic(t, "Evidence", "statistic", element.getStatistic().get(i), i); 9692 } 9693 for (int i = 0; i < element.getDistribution().size(); i++) { 9694 composeOrderedDistribution(t, "Evidence", "distribution", element.getDistribution().get(i), i); 9695 } 9696 for (int i = 0; i < element.getCertainty().size(); i++) { 9697 composeEvidenceCertaintyComponent(t, "Evidence", "certainty", element.getCertainty().get(i), i); 9698 } 9699 } 9700 9701 protected void composeEvidenceReferentGroupComponent(Complex parent, String parentType, String name, Evidence.EvidenceReferentGroupComponent element, int index) { 9702 if (element == null) 9703 return; 9704 Complex t; 9705 if (Utilities.noString(parentType)) 9706 t = parent; 9707 else { 9708 t = parent.predicate("fhir:"+parentType+'.'+name); 9709 } 9710 composeBackboneElement(t, "referentGroup", name, element, index); 9711 if (element.hasDescriptionElement()) { 9712 composeMarkdown(t, "EvidenceReferentGroupComponent", "description", element.getDescriptionElement(), -1); 9713 } 9714 for (int i = 0; i < element.getNote().size(); i++) { 9715 composeAnnotation(t, "EvidenceReferentGroupComponent", "note", element.getNote().get(i), i); 9716 } 9717 if (element.hasEvidenceSource()) { 9718 composeReference(t, "EvidenceReferentGroupComponent", "evidenceSource", element.getEvidenceSource(), -1); 9719 } 9720 if (element.hasIntendedGroup()) { 9721 composeReference(t, "EvidenceReferentGroupComponent", "intendedGroup", element.getIntendedGroup(), -1); 9722 } 9723 if (element.hasDirectnessMatch()) { 9724 composeCodeableConcept(t, "EvidenceReferentGroupComponent", "directnessMatch", element.getDirectnessMatch(), -1); 9725 } 9726 } 9727 9728 protected void composeEvidenceVariableDefinitionComponent(Complex parent, String parentType, String name, Evidence.EvidenceVariableDefinitionComponent element, int index) { 9729 if (element == null) 9730 return; 9731 Complex t; 9732 if (Utilities.noString(parentType)) 9733 t = parent; 9734 else { 9735 t = parent.predicate("fhir:"+parentType+'.'+name); 9736 } 9737 composeBackboneElement(t, "variableDefinition", name, element, index); 9738 if (element.hasDescriptionElement()) { 9739 composeMarkdown(t, "EvidenceVariableDefinitionComponent", "description", element.getDescriptionElement(), -1); 9740 } 9741 for (int i = 0; i < element.getNote().size(); i++) { 9742 composeAnnotation(t, "EvidenceVariableDefinitionComponent", "note", element.getNote().get(i), i); 9743 } 9744 if (element.hasVariableRole()) { 9745 composeCodeableConcept(t, "EvidenceVariableDefinitionComponent", "variableRole", element.getVariableRole(), -1); 9746 } 9747 if (element.hasActualDefinition()) { 9748 composeReference(t, "EvidenceVariableDefinitionComponent", "actualDefinition", element.getActualDefinition(), -1); 9749 } 9750 if (element.hasIntendedDefinition()) { 9751 composeReference(t, "EvidenceVariableDefinitionComponent", "intendedDefinition", element.getIntendedDefinition(), -1); 9752 } 9753 if (element.hasDirectnessMatch()) { 9754 composeCodeableConcept(t, "EvidenceVariableDefinitionComponent", "directnessMatch", element.getDirectnessMatch(), -1); 9755 } 9756 } 9757 9758 protected void composeEvidenceCertaintyComponent(Complex parent, String parentType, String name, Evidence.EvidenceCertaintyComponent element, int index) { 9759 if (element == null) 9760 return; 9761 Complex t; 9762 if (Utilities.noString(parentType)) 9763 t = parent; 9764 else { 9765 t = parent.predicate("fhir:"+parentType+'.'+name); 9766 } 9767 composeBackboneElement(t, "certainty", name, element, index); 9768 if (element.hasDescriptionElement()) { 9769 composeString(t, "EvidenceCertaintyComponent", "description", element.getDescriptionElement(), -1); 9770 } 9771 if (element.hasNote()) { 9772 composeAnnotation(t, "EvidenceCertaintyComponent", "note", element.getNote(), -1); 9773 } 9774 for (int i = 0; i < element.getRating().size(); i++) { 9775 composeCodeableConcept(t, "EvidenceCertaintyComponent", "rating", element.getRating().get(i), i); 9776 } 9777 for (int i = 0; i < element.getCertaintySubcomponent().size(); i++) { 9778 composeEvidenceCertaintyCertaintySubcomponentComponent(t, "EvidenceCertaintyComponent", "certaintySubcomponent", element.getCertaintySubcomponent().get(i), i); 9779 } 9780 } 9781 9782 protected void composeEvidenceCertaintyCertaintySubcomponentComponent(Complex parent, String parentType, String name, Evidence.EvidenceCertaintyCertaintySubcomponentComponent element, int index) { 9783 if (element == null) 9784 return; 9785 Complex t; 9786 if (Utilities.noString(parentType)) 9787 t = parent; 9788 else { 9789 t = parent.predicate("fhir:"+parentType+'.'+name); 9790 } 9791 composeBackboneElement(t, "certaintySubcomponent", name, element, index); 9792 if (element.hasDescriptionElement()) { 9793 composeString(t, "EvidenceCertaintyCertaintySubcomponentComponent", "description", element.getDescriptionElement(), -1); 9794 } 9795 if (element.hasNote()) { 9796 composeAnnotation(t, "EvidenceCertaintyCertaintySubcomponentComponent", "note", element.getNote(), -1); 9797 } 9798 for (int i = 0; i < element.getType().size(); i++) { 9799 composeCodeableConcept(t, "EvidenceCertaintyCertaintySubcomponentComponent", "type", element.getType().get(i), i); 9800 } 9801 for (int i = 0; i < element.getRating().size(); i++) { 9802 composeCodeableConcept(t, "EvidenceCertaintyCertaintySubcomponentComponent", "rating", element.getRating().get(i), i); 9803 } 9804 } 9805 9806 protected void composeEvidenceVariable(Complex parent, String parentType, String name, EvidenceVariable element, int index) { 9807 if (element == null) 9808 return; 9809 Complex t; 9810 if (Utilities.noString(parentType)) 9811 t = parent; 9812 else { 9813 t = parent.predicate("fhir:"+parentType+'.'+name); 9814 } 9815 composeMetadataResource(t, "EvidenceVariable", name, element, index); 9816 if (element.hasUrlElement()) { 9817 composeUri(t, "EvidenceVariable", "url", element.getUrlElement(), -1); 9818 } 9819 for (int i = 0; i < element.getIdentifier().size(); i++) { 9820 composeIdentifier(t, "EvidenceVariable", "identifier", element.getIdentifier().get(i), i); 9821 } 9822 if (element.hasVersionElement()) { 9823 composeString(t, "EvidenceVariable", "version", element.getVersionElement(), -1); 9824 } 9825 if (element.hasNameElement()) { 9826 composeString(t, "EvidenceVariable", "name", element.getNameElement(), -1); 9827 } 9828 if (element.hasTitleElement()) { 9829 composeString(t, "EvidenceVariable", "title", element.getTitleElement(), -1); 9830 } 9831 if (element.hasShortTitleElement()) { 9832 composeString(t, "EvidenceVariable", "shortTitle", element.getShortTitleElement(), -1); 9833 } 9834 if (element.hasSubtitleElement()) { 9835 composeString(t, "EvidenceVariable", "subtitle", element.getSubtitleElement(), -1); 9836 } 9837 if (element.hasStatusElement()) { 9838 composeEnum(t, "EvidenceVariable", "status", element.getStatusElement(), -1); 9839 } 9840 if (element.hasDateElement()) { 9841 composeDateTime(t, "EvidenceVariable", "date", element.getDateElement(), -1); 9842 } 9843 if (element.hasPublisherElement()) { 9844 composeString(t, "EvidenceVariable", "publisher", element.getPublisherElement(), -1); 9845 } 9846 for (int i = 0; i < element.getContact().size(); i++) { 9847 composeContactDetail(t, "EvidenceVariable", "contact", element.getContact().get(i), i); 9848 } 9849 if (element.hasDescriptionElement()) { 9850 composeMarkdown(t, "EvidenceVariable", "description", element.getDescriptionElement(), -1); 9851 } 9852 for (int i = 0; i < element.getNote().size(); i++) { 9853 composeAnnotation(t, "EvidenceVariable", "note", element.getNote().get(i), i); 9854 } 9855 for (int i = 0; i < element.getUseContext().size(); i++) { 9856 composeUsageContext(t, "EvidenceVariable", "useContext", element.getUseContext().get(i), i); 9857 } 9858 for (int i = 0; i < element.getJurisdiction().size(); i++) { 9859 composeCodeableConcept(t, "EvidenceVariable", "jurisdiction", element.getJurisdiction().get(i), i); 9860 } 9861 if (element.hasCopyrightElement()) { 9862 composeMarkdown(t, "EvidenceVariable", "copyright", element.getCopyrightElement(), -1); 9863 } 9864 if (element.hasApprovalDateElement()) { 9865 composeDate(t, "EvidenceVariable", "approvalDate", element.getApprovalDateElement(), -1); 9866 } 9867 if (element.hasLastReviewDateElement()) { 9868 composeDate(t, "EvidenceVariable", "lastReviewDate", element.getLastReviewDateElement(), -1); 9869 } 9870 if (element.hasEffectivePeriod()) { 9871 composePeriod(t, "EvidenceVariable", "effectivePeriod", element.getEffectivePeriod(), -1); 9872 } 9873 for (int i = 0; i < element.getTopic().size(); i++) { 9874 composeCodeableConcept(t, "EvidenceVariable", "topic", element.getTopic().get(i), i); 9875 } 9876 for (int i = 0; i < element.getAuthor().size(); i++) { 9877 composeContactDetail(t, "EvidenceVariable", "author", element.getAuthor().get(i), i); 9878 } 9879 for (int i = 0; i < element.getEditor().size(); i++) { 9880 composeContactDetail(t, "EvidenceVariable", "editor", element.getEditor().get(i), i); 9881 } 9882 for (int i = 0; i < element.getReviewer().size(); i++) { 9883 composeContactDetail(t, "EvidenceVariable", "reviewer", element.getReviewer().get(i), i); 9884 } 9885 for (int i = 0; i < element.getEndorser().size(); i++) { 9886 composeContactDetail(t, "EvidenceVariable", "endorser", element.getEndorser().get(i), i); 9887 } 9888 for (int i = 0; i < element.getRelatedArtifact().size(); i++) { 9889 composeRelatedArtifact(t, "EvidenceVariable", "relatedArtifact", element.getRelatedArtifact().get(i), i); 9890 } 9891 if (element.hasTypeElement()) { 9892 composeEnum(t, "EvidenceVariable", "type", element.getTypeElement(), -1); 9893 } 9894 if (element.hasActualElement()) { 9895 composeBoolean(t, "EvidenceVariable", "actual", element.getActualElement(), -1); 9896 } 9897 for (int i = 0; i < element.getCharacteristic().size(); i++) { 9898 composeEvidenceVariableCharacteristicComponent(t, "EvidenceVariable", "characteristic", element.getCharacteristic().get(i), i); 9899 } 9900 } 9901 9902 protected void composeEvidenceVariableCharacteristicComponent(Complex parent, String parentType, String name, EvidenceVariable.EvidenceVariableCharacteristicComponent element, int index) { 9903 if (element == null) 9904 return; 9905 Complex t; 9906 if (Utilities.noString(parentType)) 9907 t = parent; 9908 else { 9909 t = parent.predicate("fhir:"+parentType+'.'+name); 9910 } 9911 composeBackboneElement(t, "characteristic", name, element, index); 9912 if (element.hasDescriptionElement()) { 9913 composeString(t, "EvidenceVariableCharacteristicComponent", "description", element.getDescriptionElement(), -1); 9914 } 9915 if (element.hasDefinition()) { 9916 composeType(t, "EvidenceVariableCharacteristicComponent", "definition", element.getDefinition(), -1); 9917 } 9918 if (element.hasMethod()) { 9919 composeCodeableConcept(t, "EvidenceVariableCharacteristicComponent", "method", element.getMethod(), -1); 9920 } 9921 if (element.hasDevice()) { 9922 composeReference(t, "EvidenceVariableCharacteristicComponent", "device", element.getDevice(), -1); 9923 } 9924 for (int i = 0; i < element.getBooleanSet().size(); i++) { 9925 composeString(t, "EvidenceVariableCharacteristicComponent", "booleanSet", element.getBooleanSet().get(i), i); 9926 } 9927 if (element.hasExcludeElement()) { 9928 composeBoolean(t, "EvidenceVariableCharacteristicComponent", "exclude", element.getExcludeElement(), -1); 9929 } 9930 if (element.hasParticipantEffective()) { 9931 composeType(t, "EvidenceVariableCharacteristicComponent", "participantEffective", element.getParticipantEffective(), -1); 9932 } 9933 if (element.hasTimeFromStart()) { 9934 composeDuration(t, "EvidenceVariableCharacteristicComponent", "timeFromStart", element.getTimeFromStart(), -1); 9935 } 9936 if (element.hasGroupMeasureElement()) { 9937 composeEnum(t, "EvidenceVariableCharacteristicComponent", "groupMeasure", element.getGroupMeasureElement(), -1); 9938 } 9939 } 9940 9941 protected void composeExampleScenario(Complex parent, String parentType, String name, ExampleScenario element, int index) { 9942 if (element == null) 9943 return; 9944 Complex t; 9945 if (Utilities.noString(parentType)) 9946 t = parent; 9947 else { 9948 t = parent.predicate("fhir:"+parentType+'.'+name); 9949 } 9950 composeCanonicalResource(t, "ExampleScenario", name, element, index); 9951 if (element.hasUrlElement()) { 9952 composeUri(t, "ExampleScenario", "url", element.getUrlElement(), -1); 9953 } 9954 for (int i = 0; i < element.getIdentifier().size(); i++) { 9955 composeIdentifier(t, "ExampleScenario", "identifier", element.getIdentifier().get(i), i); 9956 } 9957 if (element.hasVersionElement()) { 9958 composeString(t, "ExampleScenario", "version", element.getVersionElement(), -1); 9959 } 9960 if (element.hasNameElement()) { 9961 composeString(t, "ExampleScenario", "name", element.getNameElement(), -1); 9962 } 9963 if (element.hasStatusElement()) { 9964 composeEnum(t, "ExampleScenario", "status", element.getStatusElement(), -1); 9965 } 9966 if (element.hasExperimentalElement()) { 9967 composeBoolean(t, "ExampleScenario", "experimental", element.getExperimentalElement(), -1); 9968 } 9969 if (element.hasDateElement()) { 9970 composeDateTime(t, "ExampleScenario", "date", element.getDateElement(), -1); 9971 } 9972 if (element.hasPublisherElement()) { 9973 composeString(t, "ExampleScenario", "publisher", element.getPublisherElement(), -1); 9974 } 9975 for (int i = 0; i < element.getContact().size(); i++) { 9976 composeContactDetail(t, "ExampleScenario", "contact", element.getContact().get(i), i); 9977 } 9978 for (int i = 0; i < element.getUseContext().size(); i++) { 9979 composeUsageContext(t, "ExampleScenario", "useContext", element.getUseContext().get(i), i); 9980 } 9981 for (int i = 0; i < element.getJurisdiction().size(); i++) { 9982 composeCodeableConcept(t, "ExampleScenario", "jurisdiction", element.getJurisdiction().get(i), i); 9983 } 9984 if (element.hasPurposeElement()) { 9985 composeMarkdown(t, "ExampleScenario", "purpose", element.getPurposeElement(), -1); 9986 } 9987 if (element.hasCopyrightElement()) { 9988 composeMarkdown(t, "ExampleScenario", "copyright", element.getCopyrightElement(), -1); 9989 } 9990 for (int i = 0; i < element.getActor().size(); i++) { 9991 composeExampleScenarioActorComponent(t, "ExampleScenario", "actor", element.getActor().get(i), i); 9992 } 9993 for (int i = 0; i < element.getInstance().size(); i++) { 9994 composeExampleScenarioInstanceComponent(t, "ExampleScenario", "instance", element.getInstance().get(i), i); 9995 } 9996 for (int i = 0; i < element.getProcess().size(); i++) { 9997 composeExampleScenarioProcessComponent(t, "ExampleScenario", "process", element.getProcess().get(i), i); 9998 } 9999 for (int i = 0; i < element.getWorkflow().size(); i++) { 10000 composeCanonical(t, "ExampleScenario", "workflow", element.getWorkflow().get(i), i); 10001 } 10002 } 10003 10004 protected void composeExampleScenarioActorComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioActorComponent element, int index) { 10005 if (element == null) 10006 return; 10007 Complex t; 10008 if (Utilities.noString(parentType)) 10009 t = parent; 10010 else { 10011 t = parent.predicate("fhir:"+parentType+'.'+name); 10012 } 10013 composeBackboneElement(t, "actor", name, element, index); 10014 if (element.hasActorIdElement()) { 10015 composeString(t, "ExampleScenarioActorComponent", "actorId", element.getActorIdElement(), -1); 10016 } 10017 if (element.hasTypeElement()) { 10018 composeEnum(t, "ExampleScenarioActorComponent", "type", element.getTypeElement(), -1); 10019 } 10020 if (element.hasNameElement()) { 10021 composeString(t, "ExampleScenarioActorComponent", "name", element.getNameElement(), -1); 10022 } 10023 if (element.hasDescriptionElement()) { 10024 composeMarkdown(t, "ExampleScenarioActorComponent", "description", element.getDescriptionElement(), -1); 10025 } 10026 } 10027 10028 protected void composeExampleScenarioInstanceComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceComponent element, int index) { 10029 if (element == null) 10030 return; 10031 Complex t; 10032 if (Utilities.noString(parentType)) 10033 t = parent; 10034 else { 10035 t = parent.predicate("fhir:"+parentType+'.'+name); 10036 } 10037 composeBackboneElement(t, "instance", name, element, index); 10038 if (element.hasResourceIdElement()) { 10039 composeString(t, "ExampleScenarioInstanceComponent", "resourceId", element.getResourceIdElement(), -1); 10040 } 10041 if (element.hasResourceTypeElement()) { 10042 composeCode(t, "ExampleScenarioInstanceComponent", "resourceType", element.getResourceTypeElement(), -1); 10043 } 10044 if (element.hasNameElement()) { 10045 composeString(t, "ExampleScenarioInstanceComponent", "name", element.getNameElement(), -1); 10046 } 10047 if (element.hasDescriptionElement()) { 10048 composeMarkdown(t, "ExampleScenarioInstanceComponent", "description", element.getDescriptionElement(), -1); 10049 } 10050 for (int i = 0; i < element.getVersion().size(); i++) { 10051 composeExampleScenarioInstanceVersionComponent(t, "ExampleScenarioInstanceComponent", "version", element.getVersion().get(i), i); 10052 } 10053 for (int i = 0; i < element.getContainedInstance().size(); i++) { 10054 composeExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenarioInstanceComponent", "containedInstance", element.getContainedInstance().get(i), i); 10055 } 10056 } 10057 10058 protected void composeExampleScenarioInstanceVersionComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceVersionComponent element, int index) { 10059 if (element == null) 10060 return; 10061 Complex t; 10062 if (Utilities.noString(parentType)) 10063 t = parent; 10064 else { 10065 t = parent.predicate("fhir:"+parentType+'.'+name); 10066 } 10067 composeBackboneElement(t, "version", name, element, index); 10068 if (element.hasVersionIdElement()) { 10069 composeString(t, "ExampleScenarioInstanceVersionComponent", "versionId", element.getVersionIdElement(), -1); 10070 } 10071 if (element.hasDescriptionElement()) { 10072 composeMarkdown(t, "ExampleScenarioInstanceVersionComponent", "description", element.getDescriptionElement(), -1); 10073 } 10074 } 10075 10076 protected void composeExampleScenarioInstanceContainedInstanceComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioInstanceContainedInstanceComponent element, int index) { 10077 if (element == null) 10078 return; 10079 Complex t; 10080 if (Utilities.noString(parentType)) 10081 t = parent; 10082 else { 10083 t = parent.predicate("fhir:"+parentType+'.'+name); 10084 } 10085 composeBackboneElement(t, "containedInstance", name, element, index); 10086 if (element.hasResourceIdElement()) { 10087 composeString(t, "ExampleScenarioInstanceContainedInstanceComponent", "resourceId", element.getResourceIdElement(), -1); 10088 } 10089 if (element.hasVersionIdElement()) { 10090 composeString(t, "ExampleScenarioInstanceContainedInstanceComponent", "versionId", element.getVersionIdElement(), -1); 10091 } 10092 } 10093 10094 protected void composeExampleScenarioProcessComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessComponent element, int index) { 10095 if (element == null) 10096 return; 10097 Complex t; 10098 if (Utilities.noString(parentType)) 10099 t = parent; 10100 else { 10101 t = parent.predicate("fhir:"+parentType+'.'+name); 10102 } 10103 composeBackboneElement(t, "process", name, element, index); 10104 if (element.hasTitleElement()) { 10105 composeString(t, "ExampleScenarioProcessComponent", "title", element.getTitleElement(), -1); 10106 } 10107 if (element.hasDescriptionElement()) { 10108 composeMarkdown(t, "ExampleScenarioProcessComponent", "description", element.getDescriptionElement(), -1); 10109 } 10110 if (element.hasPreConditionsElement()) { 10111 composeMarkdown(t, "ExampleScenarioProcessComponent", "preConditions", element.getPreConditionsElement(), -1); 10112 } 10113 if (element.hasPostConditionsElement()) { 10114 composeMarkdown(t, "ExampleScenarioProcessComponent", "postConditions", element.getPostConditionsElement(), -1); 10115 } 10116 for (int i = 0; i < element.getStep().size(); i++) { 10117 composeExampleScenarioProcessStepComponent(t, "ExampleScenarioProcessComponent", "step", element.getStep().get(i), i); 10118 } 10119 } 10120 10121 protected void composeExampleScenarioProcessStepComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepComponent element, int index) { 10122 if (element == null) 10123 return; 10124 Complex t; 10125 if (Utilities.noString(parentType)) 10126 t = parent; 10127 else { 10128 t = parent.predicate("fhir:"+parentType+'.'+name); 10129 } 10130 composeBackboneElement(t, "step", name, element, index); 10131 for (int i = 0; i < element.getProcess().size(); i++) { 10132 composeExampleScenarioProcessComponent(t, "ExampleScenarioProcessStepComponent", "process", element.getProcess().get(i), i); 10133 } 10134 if (element.hasPauseElement()) { 10135 composeBoolean(t, "ExampleScenarioProcessStepComponent", "pause", element.getPauseElement(), -1); 10136 } 10137 if (element.hasOperation()) { 10138 composeExampleScenarioProcessStepOperationComponent(t, "ExampleScenarioProcessStepComponent", "operation", element.getOperation(), -1); 10139 } 10140 for (int i = 0; i < element.getAlternative().size(); i++) { 10141 composeExampleScenarioProcessStepAlternativeComponent(t, "ExampleScenarioProcessStepComponent", "alternative", element.getAlternative().get(i), i); 10142 } 10143 } 10144 10145 protected void composeExampleScenarioProcessStepOperationComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepOperationComponent element, int index) { 10146 if (element == null) 10147 return; 10148 Complex t; 10149 if (Utilities.noString(parentType)) 10150 t = parent; 10151 else { 10152 t = parent.predicate("fhir:"+parentType+'.'+name); 10153 } 10154 composeBackboneElement(t, "operation", name, element, index); 10155 if (element.hasNumberElement()) { 10156 composeString(t, "ExampleScenarioProcessStepOperationComponent", "number", element.getNumberElement(), -1); 10157 } 10158 if (element.hasTypeElement()) { 10159 composeString(t, "ExampleScenarioProcessStepOperationComponent", "type", element.getTypeElement(), -1); 10160 } 10161 if (element.hasNameElement()) { 10162 composeString(t, "ExampleScenarioProcessStepOperationComponent", "name", element.getNameElement(), -1); 10163 } 10164 if (element.hasInitiatorElement()) { 10165 composeString(t, "ExampleScenarioProcessStepOperationComponent", "initiator", element.getInitiatorElement(), -1); 10166 } 10167 if (element.hasReceiverElement()) { 10168 composeString(t, "ExampleScenarioProcessStepOperationComponent", "receiver", element.getReceiverElement(), -1); 10169 } 10170 if (element.hasDescriptionElement()) { 10171 composeMarkdown(t, "ExampleScenarioProcessStepOperationComponent", "description", element.getDescriptionElement(), -1); 10172 } 10173 if (element.hasInitiatorActiveElement()) { 10174 composeBoolean(t, "ExampleScenarioProcessStepOperationComponent", "initiatorActive", element.getInitiatorActiveElement(), -1); 10175 } 10176 if (element.hasReceiverActiveElement()) { 10177 composeBoolean(t, "ExampleScenarioProcessStepOperationComponent", "receiverActive", element.getReceiverActiveElement(), -1); 10178 } 10179 if (element.hasRequest()) { 10180 composeExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenarioProcessStepOperationComponent", "request", element.getRequest(), -1); 10181 } 10182 if (element.hasResponse()) { 10183 composeExampleScenarioInstanceContainedInstanceComponent(t, "ExampleScenarioProcessStepOperationComponent", "response", element.getResponse(), -1); 10184 } 10185 } 10186 10187 protected void composeExampleScenarioProcessStepAlternativeComponent(Complex parent, String parentType, String name, ExampleScenario.ExampleScenarioProcessStepAlternativeComponent element, int index) { 10188 if (element == null) 10189 return; 10190 Complex t; 10191 if (Utilities.noString(parentType)) 10192 t = parent; 10193 else { 10194 t = parent.predicate("fhir:"+parentType+'.'+name); 10195 } 10196 composeBackboneElement(t, "alternative", name, element, index); 10197 if (element.hasTitleElement()) { 10198 composeString(t, "ExampleScenarioProcessStepAlternativeComponent", "title", element.getTitleElement(), -1); 10199 } 10200 if (element.hasDescriptionElement()) { 10201 composeMarkdown(t, "ExampleScenarioProcessStepAlternativeComponent", "description", element.getDescriptionElement(), -1); 10202 } 10203 for (int i = 0; i < element.getStep().size(); i++) { 10204 composeExampleScenarioProcessStepComponent(t, "ExampleScenarioProcessStepAlternativeComponent", "step", element.getStep().get(i), i); 10205 } 10206 } 10207 10208 protected void composeExplanationOfBenefit(Complex parent, String parentType, String name, ExplanationOfBenefit element, int index) { 10209 if (element == null) 10210 return; 10211 Complex t; 10212 if (Utilities.noString(parentType)) 10213 t = parent; 10214 else { 10215 t = parent.predicate("fhir:"+parentType+'.'+name); 10216 } 10217 composeDomainResource(t, "ExplanationOfBenefit", name, element, index); 10218 for (int i = 0; i < element.getIdentifier().size(); i++) { 10219 composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier().get(i), i); 10220 } 10221 if (element.hasStatusElement()) { 10222 composeEnum(t, "ExplanationOfBenefit", "status", element.getStatusElement(), -1); 10223 } 10224 if (element.hasType()) { 10225 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 10226 } 10227 if (element.hasSubType()) { 10228 composeCodeableConcept(t, "ExplanationOfBenefit", "subType", element.getSubType(), -1); 10229 } 10230 if (element.hasUseElement()) { 10231 composeEnum(t, "ExplanationOfBenefit", "use", element.getUseElement(), -1); 10232 } 10233 if (element.hasPatient()) { 10234 composeReference(t, "ExplanationOfBenefit", "patient", element.getPatient(), -1); 10235 } 10236 if (element.hasBillablePeriod()) { 10237 composePeriod(t, "ExplanationOfBenefit", "billablePeriod", element.getBillablePeriod(), -1); 10238 } 10239 if (element.hasCreatedElement()) { 10240 composeDateTime(t, "ExplanationOfBenefit", "created", element.getCreatedElement(), -1); 10241 } 10242 if (element.hasEnterer()) { 10243 composeReference(t, "ExplanationOfBenefit", "enterer", element.getEnterer(), -1); 10244 } 10245 if (element.hasInsurer()) { 10246 composeReference(t, "ExplanationOfBenefit", "insurer", element.getInsurer(), -1); 10247 } 10248 if (element.hasProvider()) { 10249 composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1); 10250 } 10251 if (element.hasPriority()) { 10252 composeCodeableConcept(t, "ExplanationOfBenefit", "priority", element.getPriority(), -1); 10253 } 10254 if (element.hasFundsReserveRequested()) { 10255 composeCodeableConcept(t, "ExplanationOfBenefit", "fundsReserveRequested", element.getFundsReserveRequested(), -1); 10256 } 10257 if (element.hasFundsReserve()) { 10258 composeCodeableConcept(t, "ExplanationOfBenefit", "fundsReserve", element.getFundsReserve(), -1); 10259 } 10260 for (int i = 0; i < element.getRelated().size(); i++) { 10261 composeExplanationOfBenefitRelatedClaimComponent(t, "ExplanationOfBenefit", "related", element.getRelated().get(i), i); 10262 } 10263 if (element.hasPrescription()) { 10264 composeReference(t, "ExplanationOfBenefit", "prescription", element.getPrescription(), -1); 10265 } 10266 if (element.hasOriginalPrescription()) { 10267 composeReference(t, "ExplanationOfBenefit", "originalPrescription", element.getOriginalPrescription(), -1); 10268 } 10269 if (element.hasPayee()) { 10270 composeExplanationOfBenefitPayeeComponent(t, "ExplanationOfBenefit", "payee", element.getPayee(), -1); 10271 } 10272 if (element.hasReferral()) { 10273 composeReference(t, "ExplanationOfBenefit", "referral", element.getReferral(), -1); 10274 } 10275 if (element.hasFacility()) { 10276 composeReference(t, "ExplanationOfBenefit", "facility", element.getFacility(), -1); 10277 } 10278 if (element.hasClaim()) { 10279 composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1); 10280 } 10281 if (element.hasClaimResponse()) { 10282 composeReference(t, "ExplanationOfBenefit", "claimResponse", element.getClaimResponse(), -1); 10283 } 10284 if (element.hasOutcomeElement()) { 10285 composeEnum(t, "ExplanationOfBenefit", "outcome", element.getOutcomeElement(), -1); 10286 } 10287 if (element.hasDispositionElement()) { 10288 composeString(t, "ExplanationOfBenefit", "disposition", element.getDispositionElement(), -1); 10289 } 10290 for (int i = 0; i < element.getPreAuthRef().size(); i++) { 10291 composeString(t, "ExplanationOfBenefit", "preAuthRef", element.getPreAuthRef().get(i), i); 10292 } 10293 for (int i = 0; i < element.getPreAuthRefPeriod().size(); i++) { 10294 composePeriod(t, "ExplanationOfBenefit", "preAuthRefPeriod", element.getPreAuthRefPeriod().get(i), i); 10295 } 10296 for (int i = 0; i < element.getCareTeam().size(); i++) { 10297 composeExplanationOfBenefitCareTeamComponent(t, "ExplanationOfBenefit", "careTeam", element.getCareTeam().get(i), i); 10298 } 10299 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 10300 composeExplanationOfBenefitSupportingInformationComponent(t, "ExplanationOfBenefit", "supportingInfo", element.getSupportingInfo().get(i), i); 10301 } 10302 for (int i = 0; i < element.getDiagnosis().size(); i++) { 10303 composeExplanationOfBenefitDiagnosisComponent(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis().get(i), i); 10304 } 10305 for (int i = 0; i < element.getProcedure().size(); i++) { 10306 composeExplanationOfBenefitProcedureComponent(t, "ExplanationOfBenefit", "procedure", element.getProcedure().get(i), i); 10307 } 10308 if (element.hasPrecedenceElement()) { 10309 composePositiveInt(t, "ExplanationOfBenefit", "precedence", element.getPrecedenceElement(), -1); 10310 } 10311 for (int i = 0; i < element.getInsurance().size(); i++) { 10312 composeExplanationOfBenefitInsuranceComponent(t, "ExplanationOfBenefit", "insurance", element.getInsurance().get(i), i); 10313 } 10314 if (element.hasAccident()) { 10315 composeExplanationOfBenefitAccidentComponent(t, "ExplanationOfBenefit", "accident", element.getAccident(), -1); 10316 } 10317 for (int i = 0; i < element.getItem().size(); i++) { 10318 composeExplanationOfBenefitItemComponent(t, "ExplanationOfBenefit", "item", element.getItem().get(i), i); 10319 } 10320 for (int i = 0; i < element.getAddItem().size(); i++) { 10321 composeExplanationOfBenefitAddedItemComponent(t, "ExplanationOfBenefit", "addItem", element.getAddItem().get(i), i); 10322 } 10323 for (int i = 0; i < element.getAdjudication().size(); i++) { 10324 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 10325 } 10326 for (int i = 0; i < element.getTotal().size(); i++) { 10327 composeExplanationOfBenefitTotalComponent(t, "ExplanationOfBenefit", "total", element.getTotal().get(i), i); 10328 } 10329 if (element.hasPayment()) { 10330 composeExplanationOfBenefitPaymentComponent(t, "ExplanationOfBenefit", "payment", element.getPayment(), -1); 10331 } 10332 if (element.hasFormCode()) { 10333 composeCodeableConcept(t, "ExplanationOfBenefit", "formCode", element.getFormCode(), -1); 10334 } 10335 if (element.hasForm()) { 10336 composeAttachment(t, "ExplanationOfBenefit", "form", element.getForm(), -1); 10337 } 10338 for (int i = 0; i < element.getProcessNote().size(); i++) { 10339 composeExplanationOfBenefitNoteComponent(t, "ExplanationOfBenefit", "processNote", element.getProcessNote().get(i), i); 10340 } 10341 if (element.hasBenefitPeriod()) { 10342 composePeriod(t, "ExplanationOfBenefit", "benefitPeriod", element.getBenefitPeriod(), -1); 10343 } 10344 for (int i = 0; i < element.getBenefitBalance().size(); i++) { 10345 composeExplanationOfBenefitBenefitBalanceComponent(t, "ExplanationOfBenefit", "benefitBalance", element.getBenefitBalance().get(i), i); 10346 } 10347 } 10348 10349 protected void composeExplanationOfBenefitRelatedClaimComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.RelatedClaimComponent element, int index) { 10350 if (element == null) 10351 return; 10352 Complex t; 10353 if (Utilities.noString(parentType)) 10354 t = parent; 10355 else { 10356 t = parent.predicate("fhir:"+parentType+'.'+name); 10357 } 10358 composeBackboneElement(t, "related", name, element, index); 10359 if (element.hasClaim()) { 10360 composeReference(t, "RelatedClaimComponent", "claim", element.getClaim(), -1); 10361 } 10362 if (element.hasRelationship()) { 10363 composeCodeableConcept(t, "RelatedClaimComponent", "relationship", element.getRelationship(), -1); 10364 } 10365 if (element.hasReference()) { 10366 composeIdentifier(t, "RelatedClaimComponent", "reference", element.getReference(), -1); 10367 } 10368 } 10369 10370 protected void composeExplanationOfBenefitPayeeComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PayeeComponent element, int index) { 10371 if (element == null) 10372 return; 10373 Complex t; 10374 if (Utilities.noString(parentType)) 10375 t = parent; 10376 else { 10377 t = parent.predicate("fhir:"+parentType+'.'+name); 10378 } 10379 composeBackboneElement(t, "payee", name, element, index); 10380 if (element.hasType()) { 10381 composeCodeableConcept(t, "PayeeComponent", "type", element.getType(), -1); 10382 } 10383 if (element.hasParty()) { 10384 composeReference(t, "PayeeComponent", "party", element.getParty(), -1); 10385 } 10386 } 10387 10388 protected void composeExplanationOfBenefitCareTeamComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.CareTeamComponent element, int index) { 10389 if (element == null) 10390 return; 10391 Complex t; 10392 if (Utilities.noString(parentType)) 10393 t = parent; 10394 else { 10395 t = parent.predicate("fhir:"+parentType+'.'+name); 10396 } 10397 composeBackboneElement(t, "careTeam", name, element, index); 10398 if (element.hasSequenceElement()) { 10399 composePositiveInt(t, "CareTeamComponent", "sequence", element.getSequenceElement(), -1); 10400 } 10401 if (element.hasProvider()) { 10402 composeReference(t, "CareTeamComponent", "provider", element.getProvider(), -1); 10403 } 10404 if (element.hasResponsibleElement()) { 10405 composeBoolean(t, "CareTeamComponent", "responsible", element.getResponsibleElement(), -1); 10406 } 10407 if (element.hasRole()) { 10408 composeCodeableConcept(t, "CareTeamComponent", "role", element.getRole(), -1); 10409 } 10410 if (element.hasQualification()) { 10411 composeCodeableConcept(t, "CareTeamComponent", "qualification", element.getQualification(), -1); 10412 } 10413 } 10414 10415 protected void composeExplanationOfBenefitSupportingInformationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SupportingInformationComponent element, int index) { 10416 if (element == null) 10417 return; 10418 Complex t; 10419 if (Utilities.noString(parentType)) 10420 t = parent; 10421 else { 10422 t = parent.predicate("fhir:"+parentType+'.'+name); 10423 } 10424 composeBackboneElement(t, "supportingInfo", name, element, index); 10425 if (element.hasSequenceElement()) { 10426 composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1); 10427 } 10428 if (element.hasCategory()) { 10429 composeCodeableConcept(t, "SupportingInformationComponent", "category", element.getCategory(), -1); 10430 } 10431 if (element.hasCode()) { 10432 composeCodeableConcept(t, "SupportingInformationComponent", "code", element.getCode(), -1); 10433 } 10434 if (element.hasTiming()) { 10435 composeType(t, "SupportingInformationComponent", "timing", element.getTiming(), -1); 10436 } 10437 if (element.hasValue()) { 10438 composeType(t, "SupportingInformationComponent", "value", element.getValue(), -1); 10439 } 10440 if (element.hasReason()) { 10441 composeCoding(t, "SupportingInformationComponent", "reason", element.getReason(), -1); 10442 } 10443 } 10444 10445 protected void composeExplanationOfBenefitDiagnosisComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DiagnosisComponent element, int index) { 10446 if (element == null) 10447 return; 10448 Complex t; 10449 if (Utilities.noString(parentType)) 10450 t = parent; 10451 else { 10452 t = parent.predicate("fhir:"+parentType+'.'+name); 10453 } 10454 composeBackboneElement(t, "diagnosis", name, element, index); 10455 if (element.hasSequenceElement()) { 10456 composePositiveInt(t, "DiagnosisComponent", "sequence", element.getSequenceElement(), -1); 10457 } 10458 if (element.hasDiagnosis()) { 10459 composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1); 10460 } 10461 for (int i = 0; i < element.getType().size(); i++) { 10462 composeCodeableConcept(t, "DiagnosisComponent", "type", element.getType().get(i), i); 10463 } 10464 if (element.hasOnAdmission()) { 10465 composeCodeableConcept(t, "DiagnosisComponent", "onAdmission", element.getOnAdmission(), -1); 10466 } 10467 if (element.hasPackageCode()) { 10468 composeCodeableConcept(t, "DiagnosisComponent", "packageCode", element.getPackageCode(), -1); 10469 } 10470 } 10471 10472 protected void composeExplanationOfBenefitProcedureComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ProcedureComponent element, int index) { 10473 if (element == null) 10474 return; 10475 Complex t; 10476 if (Utilities.noString(parentType)) 10477 t = parent; 10478 else { 10479 t = parent.predicate("fhir:"+parentType+'.'+name); 10480 } 10481 composeBackboneElement(t, "procedure", name, element, index); 10482 if (element.hasSequenceElement()) { 10483 composePositiveInt(t, "ProcedureComponent", "sequence", element.getSequenceElement(), -1); 10484 } 10485 for (int i = 0; i < element.getType().size(); i++) { 10486 composeCodeableConcept(t, "ProcedureComponent", "type", element.getType().get(i), i); 10487 } 10488 if (element.hasDateElement()) { 10489 composeDateTime(t, "ProcedureComponent", "date", element.getDateElement(), -1); 10490 } 10491 if (element.hasProcedure()) { 10492 composeType(t, "ProcedureComponent", "procedure", element.getProcedure(), -1); 10493 } 10494 for (int i = 0; i < element.getUdi().size(); i++) { 10495 composeReference(t, "ProcedureComponent", "udi", element.getUdi().get(i), i); 10496 } 10497 } 10498 10499 protected void composeExplanationOfBenefitInsuranceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.InsuranceComponent element, int index) { 10500 if (element == null) 10501 return; 10502 Complex t; 10503 if (Utilities.noString(parentType)) 10504 t = parent; 10505 else { 10506 t = parent.predicate("fhir:"+parentType+'.'+name); 10507 } 10508 composeBackboneElement(t, "insurance", name, element, index); 10509 if (element.hasFocalElement()) { 10510 composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1); 10511 } 10512 if (element.hasCoverage()) { 10513 composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1); 10514 } 10515 for (int i = 0; i < element.getPreAuthRef().size(); i++) { 10516 composeString(t, "InsuranceComponent", "preAuthRef", element.getPreAuthRef().get(i), i); 10517 } 10518 } 10519 10520 protected void composeExplanationOfBenefitAccidentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AccidentComponent element, int index) { 10521 if (element == null) 10522 return; 10523 Complex t; 10524 if (Utilities.noString(parentType)) 10525 t = parent; 10526 else { 10527 t = parent.predicate("fhir:"+parentType+'.'+name); 10528 } 10529 composeBackboneElement(t, "accident", name, element, index); 10530 if (element.hasDateElement()) { 10531 composeDate(t, "AccidentComponent", "date", element.getDateElement(), -1); 10532 } 10533 if (element.hasType()) { 10534 composeCodeableConcept(t, "AccidentComponent", "type", element.getType(), -1); 10535 } 10536 if (element.hasLocation()) { 10537 composeType(t, "AccidentComponent", "location", element.getLocation(), -1); 10538 } 10539 } 10540 10541 protected void composeExplanationOfBenefitItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ItemComponent element, int index) { 10542 if (element == null) 10543 return; 10544 Complex t; 10545 if (Utilities.noString(parentType)) 10546 t = parent; 10547 else { 10548 t = parent.predicate("fhir:"+parentType+'.'+name); 10549 } 10550 composeBackboneElement(t, "item", name, element, index); 10551 if (element.hasSequenceElement()) { 10552 composePositiveInt(t, "ItemComponent", "sequence", element.getSequenceElement(), -1); 10553 } 10554 for (int i = 0; i < element.getCareTeamSequence().size(); i++) { 10555 composePositiveInt(t, "ItemComponent", "careTeamSequence", element.getCareTeamSequence().get(i), i); 10556 } 10557 for (int i = 0; i < element.getDiagnosisSequence().size(); i++) { 10558 composePositiveInt(t, "ItemComponent", "diagnosisSequence", element.getDiagnosisSequence().get(i), i); 10559 } 10560 for (int i = 0; i < element.getProcedureSequence().size(); i++) { 10561 composePositiveInt(t, "ItemComponent", "procedureSequence", element.getProcedureSequence().get(i), i); 10562 } 10563 for (int i = 0; i < element.getInformationSequence().size(); i++) { 10564 composePositiveInt(t, "ItemComponent", "informationSequence", element.getInformationSequence().get(i), i); 10565 } 10566 if (element.hasRevenue()) { 10567 composeCodeableConcept(t, "ItemComponent", "revenue", element.getRevenue(), -1); 10568 } 10569 if (element.hasCategory()) { 10570 composeCodeableConcept(t, "ItemComponent", "category", element.getCategory(), -1); 10571 } 10572 if (element.hasProductOrService()) { 10573 composeCodeableConcept(t, "ItemComponent", "productOrService", element.getProductOrService(), -1); 10574 } 10575 for (int i = 0; i < element.getModifier().size(); i++) { 10576 composeCodeableConcept(t, "ItemComponent", "modifier", element.getModifier().get(i), i); 10577 } 10578 for (int i = 0; i < element.getProgramCode().size(); i++) { 10579 composeCodeableConcept(t, "ItemComponent", "programCode", element.getProgramCode().get(i), i); 10580 } 10581 if (element.hasServiced()) { 10582 composeType(t, "ItemComponent", "serviced", element.getServiced(), -1); 10583 } 10584 if (element.hasLocation()) { 10585 composeType(t, "ItemComponent", "location", element.getLocation(), -1); 10586 } 10587 if (element.hasQuantity()) { 10588 composeQuantity(t, "ItemComponent", "quantity", element.getQuantity(), -1); 10589 } 10590 if (element.hasUnitPrice()) { 10591 composeMoney(t, "ItemComponent", "unitPrice", element.getUnitPrice(), -1); 10592 } 10593 if (element.hasFactorElement()) { 10594 composeDecimal(t, "ItemComponent", "factor", element.getFactorElement(), -1); 10595 } 10596 if (element.hasNet()) { 10597 composeMoney(t, "ItemComponent", "net", element.getNet(), -1); 10598 } 10599 for (int i = 0; i < element.getUdi().size(); i++) { 10600 composeReference(t, "ItemComponent", "udi", element.getUdi().get(i), i); 10601 } 10602 if (element.hasBodySite()) { 10603 composeCodeableConcept(t, "ItemComponent", "bodySite", element.getBodySite(), -1); 10604 } 10605 for (int i = 0; i < element.getSubSite().size(); i++) { 10606 composeCodeableConcept(t, "ItemComponent", "subSite", element.getSubSite().get(i), i); 10607 } 10608 for (int i = 0; i < element.getEncounter().size(); i++) { 10609 composeReference(t, "ItemComponent", "encounter", element.getEncounter().get(i), i); 10610 } 10611 for (int i = 0; i < element.getNoteNumber().size(); i++) { 10612 composePositiveInt(t, "ItemComponent", "noteNumber", element.getNoteNumber().get(i), i); 10613 } 10614 for (int i = 0; i < element.getAdjudication().size(); i++) { 10615 composeExplanationOfBenefitAdjudicationComponent(t, "ItemComponent", "adjudication", element.getAdjudication().get(i), i); 10616 } 10617 for (int i = 0; i < element.getDetail().size(); i++) { 10618 composeExplanationOfBenefitDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i); 10619 } 10620 } 10621 10622 protected void composeExplanationOfBenefitAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AdjudicationComponent element, int index) { 10623 if (element == null) 10624 return; 10625 Complex t; 10626 if (Utilities.noString(parentType)) 10627 t = parent; 10628 else { 10629 t = parent.predicate("fhir:"+parentType+'.'+name); 10630 } 10631 composeBackboneElement(t, "adjudication", name, element, index); 10632 if (element.hasCategory()) { 10633 composeCodeableConcept(t, "AdjudicationComponent", "category", element.getCategory(), -1); 10634 } 10635 if (element.hasReason()) { 10636 composeCodeableConcept(t, "AdjudicationComponent", "reason", element.getReason(), -1); 10637 } 10638 if (element.hasAmount()) { 10639 composeMoney(t, "AdjudicationComponent", "amount", element.getAmount(), -1); 10640 } 10641 if (element.hasValueElement()) { 10642 composeDecimal(t, "AdjudicationComponent", "value", element.getValueElement(), -1); 10643 } 10644 } 10645 10646 protected void composeExplanationOfBenefitDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DetailComponent element, int index) { 10647 if (element == null) 10648 return; 10649 Complex t; 10650 if (Utilities.noString(parentType)) 10651 t = parent; 10652 else { 10653 t = parent.predicate("fhir:"+parentType+'.'+name); 10654 } 10655 composeBackboneElement(t, "detail", name, element, index); 10656 if (element.hasSequenceElement()) { 10657 composePositiveInt(t, "DetailComponent", "sequence", element.getSequenceElement(), -1); 10658 } 10659 if (element.hasRevenue()) { 10660 composeCodeableConcept(t, "DetailComponent", "revenue", element.getRevenue(), -1); 10661 } 10662 if (element.hasCategory()) { 10663 composeCodeableConcept(t, "DetailComponent", "category", element.getCategory(), -1); 10664 } 10665 if (element.hasProductOrService()) { 10666 composeCodeableConcept(t, "DetailComponent", "productOrService", element.getProductOrService(), -1); 10667 } 10668 for (int i = 0; i < element.getModifier().size(); i++) { 10669 composeCodeableConcept(t, "DetailComponent", "modifier", element.getModifier().get(i), i); 10670 } 10671 for (int i = 0; i < element.getProgramCode().size(); i++) { 10672 composeCodeableConcept(t, "DetailComponent", "programCode", element.getProgramCode().get(i), i); 10673 } 10674 if (element.hasQuantity()) { 10675 composeQuantity(t, "DetailComponent", "quantity", element.getQuantity(), -1); 10676 } 10677 if (element.hasUnitPrice()) { 10678 composeMoney(t, "DetailComponent", "unitPrice", element.getUnitPrice(), -1); 10679 } 10680 if (element.hasFactorElement()) { 10681 composeDecimal(t, "DetailComponent", "factor", element.getFactorElement(), -1); 10682 } 10683 if (element.hasNet()) { 10684 composeMoney(t, "DetailComponent", "net", element.getNet(), -1); 10685 } 10686 for (int i = 0; i < element.getUdi().size(); i++) { 10687 composeReference(t, "DetailComponent", "udi", element.getUdi().get(i), i); 10688 } 10689 for (int i = 0; i < element.getNoteNumber().size(); i++) { 10690 composePositiveInt(t, "DetailComponent", "noteNumber", element.getNoteNumber().get(i), i); 10691 } 10692 for (int i = 0; i < element.getAdjudication().size(); i++) { 10693 composeExplanationOfBenefitAdjudicationComponent(t, "DetailComponent", "adjudication", element.getAdjudication().get(i), i); 10694 } 10695 for (int i = 0; i < element.getSubDetail().size(); i++) { 10696 composeExplanationOfBenefitSubDetailComponent(t, "DetailComponent", "subDetail", element.getSubDetail().get(i), i); 10697 } 10698 } 10699 10700 protected void composeExplanationOfBenefitSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SubDetailComponent 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, "subDetail", name, element, index); 10710 if (element.hasSequenceElement()) { 10711 composePositiveInt(t, "SubDetailComponent", "sequence", element.getSequenceElement(), -1); 10712 } 10713 if (element.hasRevenue()) { 10714 composeCodeableConcept(t, "SubDetailComponent", "revenue", element.getRevenue(), -1); 10715 } 10716 if (element.hasCategory()) { 10717 composeCodeableConcept(t, "SubDetailComponent", "category", element.getCategory(), -1); 10718 } 10719 if (element.hasProductOrService()) { 10720 composeCodeableConcept(t, "SubDetailComponent", "productOrService", element.getProductOrService(), -1); 10721 } 10722 for (int i = 0; i < element.getModifier().size(); i++) { 10723 composeCodeableConcept(t, "SubDetailComponent", "modifier", element.getModifier().get(i), i); 10724 } 10725 for (int i = 0; i < element.getProgramCode().size(); i++) { 10726 composeCodeableConcept(t, "SubDetailComponent", "programCode", element.getProgramCode().get(i), i); 10727 } 10728 if (element.hasQuantity()) { 10729 composeQuantity(t, "SubDetailComponent", "quantity", element.getQuantity(), -1); 10730 } 10731 if (element.hasUnitPrice()) { 10732 composeMoney(t, "SubDetailComponent", "unitPrice", element.getUnitPrice(), -1); 10733 } 10734 if (element.hasFactorElement()) { 10735 composeDecimal(t, "SubDetailComponent", "factor", element.getFactorElement(), -1); 10736 } 10737 if (element.hasNet()) { 10738 composeMoney(t, "SubDetailComponent", "net", element.getNet(), -1); 10739 } 10740 for (int i = 0; i < element.getUdi().size(); i++) { 10741 composeReference(t, "SubDetailComponent", "udi", element.getUdi().get(i), i); 10742 } 10743 for (int i = 0; i < element.getNoteNumber().size(); i++) { 10744 composePositiveInt(t, "SubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i); 10745 } 10746 for (int i = 0; i < element.getAdjudication().size(); i++) { 10747 composeExplanationOfBenefitAdjudicationComponent(t, "SubDetailComponent", "adjudication", element.getAdjudication().get(i), i); 10748 } 10749 } 10750 10751 protected void composeExplanationOfBenefitAddedItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemComponent element, int index) { 10752 if (element == null) 10753 return; 10754 Complex t; 10755 if (Utilities.noString(parentType)) 10756 t = parent; 10757 else { 10758 t = parent.predicate("fhir:"+parentType+'.'+name); 10759 } 10760 composeBackboneElement(t, "addItem", name, element, index); 10761 for (int i = 0; i < element.getItemSequence().size(); i++) { 10762 composePositiveInt(t, "AddedItemComponent", "itemSequence", element.getItemSequence().get(i), i); 10763 } 10764 for (int i = 0; i < element.getDetailSequence().size(); i++) { 10765 composePositiveInt(t, "AddedItemComponent", "detailSequence", element.getDetailSequence().get(i), i); 10766 } 10767 for (int i = 0; i < element.getSubDetailSequence().size(); i++) { 10768 composePositiveInt(t, "AddedItemComponent", "subDetailSequence", element.getSubDetailSequence().get(i), i); 10769 } 10770 for (int i = 0; i < element.getProvider().size(); i++) { 10771 composeReference(t, "AddedItemComponent", "provider", element.getProvider().get(i), i); 10772 } 10773 if (element.hasProductOrService()) { 10774 composeCodeableConcept(t, "AddedItemComponent", "productOrService", element.getProductOrService(), -1); 10775 } 10776 for (int i = 0; i < element.getModifier().size(); i++) { 10777 composeCodeableConcept(t, "AddedItemComponent", "modifier", element.getModifier().get(i), i); 10778 } 10779 for (int i = 0; i < element.getProgramCode().size(); i++) { 10780 composeCodeableConcept(t, "AddedItemComponent", "programCode", element.getProgramCode().get(i), i); 10781 } 10782 if (element.hasServiced()) { 10783 composeType(t, "AddedItemComponent", "serviced", element.getServiced(), -1); 10784 } 10785 if (element.hasLocation()) { 10786 composeType(t, "AddedItemComponent", "location", element.getLocation(), -1); 10787 } 10788 if (element.hasQuantity()) { 10789 composeQuantity(t, "AddedItemComponent", "quantity", element.getQuantity(), -1); 10790 } 10791 if (element.hasUnitPrice()) { 10792 composeMoney(t, "AddedItemComponent", "unitPrice", element.getUnitPrice(), -1); 10793 } 10794 if (element.hasFactorElement()) { 10795 composeDecimal(t, "AddedItemComponent", "factor", element.getFactorElement(), -1); 10796 } 10797 if (element.hasNet()) { 10798 composeMoney(t, "AddedItemComponent", "net", element.getNet(), -1); 10799 } 10800 if (element.hasBodySite()) { 10801 composeCodeableConcept(t, "AddedItemComponent", "bodySite", element.getBodySite(), -1); 10802 } 10803 for (int i = 0; i < element.getSubSite().size(); i++) { 10804 composeCodeableConcept(t, "AddedItemComponent", "subSite", element.getSubSite().get(i), i); 10805 } 10806 for (int i = 0; i < element.getNoteNumber().size(); i++) { 10807 composePositiveInt(t, "AddedItemComponent", "noteNumber", element.getNoteNumber().get(i), i); 10808 } 10809 for (int i = 0; i < element.getAdjudication().size(); i++) { 10810 composeExplanationOfBenefitAdjudicationComponent(t, "AddedItemComponent", "adjudication", element.getAdjudication().get(i), i); 10811 } 10812 for (int i = 0; i < element.getDetail().size(); i++) { 10813 composeExplanationOfBenefitAddedItemDetailComponent(t, "AddedItemComponent", "detail", element.getDetail().get(i), i); 10814 } 10815 } 10816 10817 protected void composeExplanationOfBenefitAddedItemDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemDetailComponent element, int index) { 10818 if (element == null) 10819 return; 10820 Complex t; 10821 if (Utilities.noString(parentType)) 10822 t = parent; 10823 else { 10824 t = parent.predicate("fhir:"+parentType+'.'+name); 10825 } 10826 composeBackboneElement(t, "detail", name, element, index); 10827 if (element.hasProductOrService()) { 10828 composeCodeableConcept(t, "AddedItemDetailComponent", "productOrService", element.getProductOrService(), -1); 10829 } 10830 for (int i = 0; i < element.getModifier().size(); i++) { 10831 composeCodeableConcept(t, "AddedItemDetailComponent", "modifier", element.getModifier().get(i), i); 10832 } 10833 if (element.hasQuantity()) { 10834 composeQuantity(t, "AddedItemDetailComponent", "quantity", element.getQuantity(), -1); 10835 } 10836 if (element.hasUnitPrice()) { 10837 composeMoney(t, "AddedItemDetailComponent", "unitPrice", element.getUnitPrice(), -1); 10838 } 10839 if (element.hasFactorElement()) { 10840 composeDecimal(t, "AddedItemDetailComponent", "factor", element.getFactorElement(), -1); 10841 } 10842 if (element.hasNet()) { 10843 composeMoney(t, "AddedItemDetailComponent", "net", element.getNet(), -1); 10844 } 10845 for (int i = 0; i < element.getNoteNumber().size(); i++) { 10846 composePositiveInt(t, "AddedItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i); 10847 } 10848 for (int i = 0; i < element.getAdjudication().size(); i++) { 10849 composeExplanationOfBenefitAdjudicationComponent(t, "AddedItemDetailComponent", "adjudication", element.getAdjudication().get(i), i); 10850 } 10851 for (int i = 0; i < element.getSubDetail().size(); i++) { 10852 composeExplanationOfBenefitAddedItemDetailSubDetailComponent(t, "AddedItemDetailComponent", "subDetail", element.getSubDetail().get(i), i); 10853 } 10854 } 10855 10856 protected void composeExplanationOfBenefitAddedItemDetailSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemDetailSubDetailComponent 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, "subDetail", name, element, index); 10866 if (element.hasProductOrService()) { 10867 composeCodeableConcept(t, "AddedItemDetailSubDetailComponent", "productOrService", element.getProductOrService(), -1); 10868 } 10869 for (int i = 0; i < element.getModifier().size(); i++) { 10870 composeCodeableConcept(t, "AddedItemDetailSubDetailComponent", "modifier", element.getModifier().get(i), i); 10871 } 10872 if (element.hasQuantity()) { 10873 composeQuantity(t, "AddedItemDetailSubDetailComponent", "quantity", element.getQuantity(), -1); 10874 } 10875 if (element.hasUnitPrice()) { 10876 composeMoney(t, "AddedItemDetailSubDetailComponent", "unitPrice", element.getUnitPrice(), -1); 10877 } 10878 if (element.hasFactorElement()) { 10879 composeDecimal(t, "AddedItemDetailSubDetailComponent", "factor", element.getFactorElement(), -1); 10880 } 10881 if (element.hasNet()) { 10882 composeMoney(t, "AddedItemDetailSubDetailComponent", "net", element.getNet(), -1); 10883 } 10884 for (int i = 0; i < element.getNoteNumber().size(); i++) { 10885 composePositiveInt(t, "AddedItemDetailSubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i); 10886 } 10887 for (int i = 0; i < element.getAdjudication().size(); i++) { 10888 composeExplanationOfBenefitAdjudicationComponent(t, "AddedItemDetailSubDetailComponent", "adjudication", element.getAdjudication().get(i), i); 10889 } 10890 } 10891 10892 protected void composeExplanationOfBenefitTotalComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.TotalComponent element, int index) { 10893 if (element == null) 10894 return; 10895 Complex t; 10896 if (Utilities.noString(parentType)) 10897 t = parent; 10898 else { 10899 t = parent.predicate("fhir:"+parentType+'.'+name); 10900 } 10901 composeBackboneElement(t, "total", name, element, index); 10902 if (element.hasCategory()) { 10903 composeCodeableConcept(t, "TotalComponent", "category", element.getCategory(), -1); 10904 } 10905 if (element.hasAmount()) { 10906 composeMoney(t, "TotalComponent", "amount", element.getAmount(), -1); 10907 } 10908 } 10909 10910 protected void composeExplanationOfBenefitPaymentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PaymentComponent element, int index) { 10911 if (element == null) 10912 return; 10913 Complex t; 10914 if (Utilities.noString(parentType)) 10915 t = parent; 10916 else { 10917 t = parent.predicate("fhir:"+parentType+'.'+name); 10918 } 10919 composeBackboneElement(t, "payment", name, element, index); 10920 if (element.hasType()) { 10921 composeCodeableConcept(t, "PaymentComponent", "type", element.getType(), -1); 10922 } 10923 if (element.hasAdjustment()) { 10924 composeMoney(t, "PaymentComponent", "adjustment", element.getAdjustment(), -1); 10925 } 10926 if (element.hasAdjustmentReason()) { 10927 composeCodeableConcept(t, "PaymentComponent", "adjustmentReason", element.getAdjustmentReason(), -1); 10928 } 10929 if (element.hasDateElement()) { 10930 composeDate(t, "PaymentComponent", "date", element.getDateElement(), -1); 10931 } 10932 if (element.hasAmount()) { 10933 composeMoney(t, "PaymentComponent", "amount", element.getAmount(), -1); 10934 } 10935 if (element.hasIdentifier()) { 10936 composeIdentifier(t, "PaymentComponent", "identifier", element.getIdentifier(), -1); 10937 } 10938 } 10939 10940 protected void composeExplanationOfBenefitNoteComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.NoteComponent element, int index) { 10941 if (element == null) 10942 return; 10943 Complex t; 10944 if (Utilities.noString(parentType)) 10945 t = parent; 10946 else { 10947 t = parent.predicate("fhir:"+parentType+'.'+name); 10948 } 10949 composeBackboneElement(t, "processNote", name, element, index); 10950 if (element.hasNumberElement()) { 10951 composePositiveInt(t, "NoteComponent", "number", element.getNumberElement(), -1); 10952 } 10953 if (element.hasTypeElement()) { 10954 composeEnum(t, "NoteComponent", "type", element.getTypeElement(), -1); 10955 } 10956 if (element.hasTextElement()) { 10957 composeString(t, "NoteComponent", "text", element.getTextElement(), -1); 10958 } 10959 if (element.hasLanguage()) { 10960 composeCodeableConcept(t, "NoteComponent", "language", element.getLanguage(), -1); 10961 } 10962 } 10963 10964 protected void composeExplanationOfBenefitBenefitBalanceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitBalanceComponent element, int index) { 10965 if (element == null) 10966 return; 10967 Complex t; 10968 if (Utilities.noString(parentType)) 10969 t = parent; 10970 else { 10971 t = parent.predicate("fhir:"+parentType+'.'+name); 10972 } 10973 composeBackboneElement(t, "benefitBalance", name, element, index); 10974 if (element.hasCategory()) { 10975 composeCodeableConcept(t, "BenefitBalanceComponent", "category", element.getCategory(), -1); 10976 } 10977 if (element.hasExcludedElement()) { 10978 composeBoolean(t, "BenefitBalanceComponent", "excluded", element.getExcludedElement(), -1); 10979 } 10980 if (element.hasNameElement()) { 10981 composeString(t, "BenefitBalanceComponent", "name", element.getNameElement(), -1); 10982 } 10983 if (element.hasDescriptionElement()) { 10984 composeString(t, "BenefitBalanceComponent", "description", element.getDescriptionElement(), -1); 10985 } 10986 if (element.hasNetwork()) { 10987 composeCodeableConcept(t, "BenefitBalanceComponent", "network", element.getNetwork(), -1); 10988 } 10989 if (element.hasUnit()) { 10990 composeCodeableConcept(t, "BenefitBalanceComponent", "unit", element.getUnit(), -1); 10991 } 10992 if (element.hasTerm()) { 10993 composeCodeableConcept(t, "BenefitBalanceComponent", "term", element.getTerm(), -1); 10994 } 10995 for (int i = 0; i < element.getFinancial().size(); i++) { 10996 composeExplanationOfBenefitBenefitComponent(t, "BenefitBalanceComponent", "financial", element.getFinancial().get(i), i); 10997 } 10998 } 10999 11000 protected void composeExplanationOfBenefitBenefitComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitComponent element, int index) { 11001 if (element == null) 11002 return; 11003 Complex t; 11004 if (Utilities.noString(parentType)) 11005 t = parent; 11006 else { 11007 t = parent.predicate("fhir:"+parentType+'.'+name); 11008 } 11009 composeBackboneElement(t, "financial", name, element, index); 11010 if (element.hasType()) { 11011 composeCodeableConcept(t, "BenefitComponent", "type", element.getType(), -1); 11012 } 11013 if (element.hasAllowed()) { 11014 composeType(t, "BenefitComponent", "allowed", element.getAllowed(), -1); 11015 } 11016 if (element.hasUsed()) { 11017 composeType(t, "BenefitComponent", "used", element.getUsed(), -1); 11018 } 11019 } 11020 11021 protected void composeFamilyMemberHistory(Complex parent, String parentType, String name, FamilyMemberHistory element, int index) { 11022 if (element == null) 11023 return; 11024 Complex t; 11025 if (Utilities.noString(parentType)) 11026 t = parent; 11027 else { 11028 t = parent.predicate("fhir:"+parentType+'.'+name); 11029 } 11030 composeDomainResource(t, "FamilyMemberHistory", name, element, index); 11031 for (int i = 0; i < element.getIdentifier().size(); i++) { 11032 composeIdentifier(t, "FamilyMemberHistory", "identifier", element.getIdentifier().get(i), i); 11033 } 11034 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) { 11035 composeCanonical(t, "FamilyMemberHistory", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 11036 } 11037 for (int i = 0; i < element.getInstantiatesUri().size(); i++) { 11038 composeUri(t, "FamilyMemberHistory", "instantiatesUri", element.getInstantiatesUri().get(i), i); 11039 } 11040 if (element.hasStatusElement()) { 11041 composeEnum(t, "FamilyMemberHistory", "status", element.getStatusElement(), -1); 11042 } 11043 if (element.hasDataAbsentReason()) { 11044 composeCodeableConcept(t, "FamilyMemberHistory", "dataAbsentReason", element.getDataAbsentReason(), -1); 11045 } 11046 if (element.hasPatient()) { 11047 composeReference(t, "FamilyMemberHistory", "patient", element.getPatient(), -1); 11048 } 11049 if (element.hasDateElement()) { 11050 composeDateTime(t, "FamilyMemberHistory", "date", element.getDateElement(), -1); 11051 } 11052 if (element.hasNameElement()) { 11053 composeString(t, "FamilyMemberHistory", "name", element.getNameElement(), -1); 11054 } 11055 if (element.hasRelationship()) { 11056 composeCodeableConcept(t, "FamilyMemberHistory", "relationship", element.getRelationship(), -1); 11057 } 11058 if (element.hasSex()) { 11059 composeCodeableConcept(t, "FamilyMemberHistory", "sex", element.getSex(), -1); 11060 } 11061 if (element.hasBorn()) { 11062 composeType(t, "FamilyMemberHistory", "born", element.getBorn(), -1); 11063 } 11064 if (element.hasAge()) { 11065 composeType(t, "FamilyMemberHistory", "age", element.getAge(), -1); 11066 } 11067 if (element.hasEstimatedAgeElement()) { 11068 composeBoolean(t, "FamilyMemberHistory", "estimatedAge", element.getEstimatedAgeElement(), -1); 11069 } 11070 if (element.hasDeceased()) { 11071 composeType(t, "FamilyMemberHistory", "deceased", element.getDeceased(), -1); 11072 } 11073 for (int i = 0; i < element.getReason().size(); i++) { 11074 composeCodeableReference(t, "FamilyMemberHistory", "reason", element.getReason().get(i), i); 11075 } 11076 for (int i = 0; i < element.getNote().size(); i++) { 11077 composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i); 11078 } 11079 for (int i = 0; i < element.getCondition().size(); i++) { 11080 composeFamilyMemberHistoryConditionComponent(t, "FamilyMemberHistory", "condition", element.getCondition().get(i), i); 11081 } 11082 for (int i = 0; i < element.getProcedure().size(); i++) { 11083 composeFamilyMemberHistoryProcedureComponent(t, "FamilyMemberHistory", "procedure", element.getProcedure().get(i), i); 11084 } 11085 } 11086 11087 protected void composeFamilyMemberHistoryConditionComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryConditionComponent element, int index) { 11088 if (element == null) 11089 return; 11090 Complex t; 11091 if (Utilities.noString(parentType)) 11092 t = parent; 11093 else { 11094 t = parent.predicate("fhir:"+parentType+'.'+name); 11095 } 11096 composeBackboneElement(t, "condition", name, element, index); 11097 if (element.hasCode()) { 11098 composeCodeableConcept(t, "FamilyMemberHistoryConditionComponent", "code", element.getCode(), -1); 11099 } 11100 if (element.hasOutcome()) { 11101 composeCodeableConcept(t, "FamilyMemberHistoryConditionComponent", "outcome", element.getOutcome(), -1); 11102 } 11103 if (element.hasContributedToDeathElement()) { 11104 composeBoolean(t, "FamilyMemberHistoryConditionComponent", "contributedToDeath", element.getContributedToDeathElement(), -1); 11105 } 11106 if (element.hasOnset()) { 11107 composeType(t, "FamilyMemberHistoryConditionComponent", "onset", element.getOnset(), -1); 11108 } 11109 for (int i = 0; i < element.getNote().size(); i++) { 11110 composeAnnotation(t, "FamilyMemberHistoryConditionComponent", "note", element.getNote().get(i), i); 11111 } 11112 } 11113 11114 protected void composeFamilyMemberHistoryProcedureComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryProcedureComponent element, int index) { 11115 if (element == null) 11116 return; 11117 Complex t; 11118 if (Utilities.noString(parentType)) 11119 t = parent; 11120 else { 11121 t = parent.predicate("fhir:"+parentType+'.'+name); 11122 } 11123 composeBackboneElement(t, "procedure", name, element, index); 11124 if (element.hasCode()) { 11125 composeCodeableConcept(t, "FamilyMemberHistoryProcedureComponent", "code", element.getCode(), -1); 11126 } 11127 if (element.hasOutcome()) { 11128 composeCodeableConcept(t, "FamilyMemberHistoryProcedureComponent", "outcome", element.getOutcome(), -1); 11129 } 11130 if (element.hasContributedToDeathElement()) { 11131 composeBoolean(t, "FamilyMemberHistoryProcedureComponent", "contributedToDeath", element.getContributedToDeathElement(), -1); 11132 } 11133 if (element.hasPerformed()) { 11134 composeType(t, "FamilyMemberHistoryProcedureComponent", "performed", element.getPerformed(), -1); 11135 } 11136 for (int i = 0; i < element.getNote().size(); i++) { 11137 composeAnnotation(t, "FamilyMemberHistoryProcedureComponent", "note", element.getNote().get(i), i); 11138 } 11139 } 11140 11141 protected void composeFlag(Complex parent, String parentType, String name, Flag element, int index) { 11142 if (element == null) 11143 return; 11144 Complex t; 11145 if (Utilities.noString(parentType)) 11146 t = parent; 11147 else { 11148 t = parent.predicate("fhir:"+parentType+'.'+name); 11149 } 11150 composeDomainResource(t, "Flag", name, element, index); 11151 for (int i = 0; i < element.getIdentifier().size(); i++) { 11152 composeIdentifier(t, "Flag", "identifier", element.getIdentifier().get(i), i); 11153 } 11154 if (element.hasStatusElement()) { 11155 composeEnum(t, "Flag", "status", element.getStatusElement(), -1); 11156 } 11157 for (int i = 0; i < element.getCategory().size(); i++) { 11158 composeCodeableConcept(t, "Flag", "category", element.getCategory().get(i), i); 11159 } 11160 if (element.hasCode()) { 11161 composeCodeableConcept(t, "Flag", "code", element.getCode(), -1); 11162 } 11163 if (element.hasSubject()) { 11164 composeReference(t, "Flag", "subject", element.getSubject(), -1); 11165 } 11166 if (element.hasPeriod()) { 11167 composePeriod(t, "Flag", "period", element.getPeriod(), -1); 11168 } 11169 if (element.hasEncounter()) { 11170 composeReference(t, "Flag", "encounter", element.getEncounter(), -1); 11171 } 11172 if (element.hasAuthor()) { 11173 composeReference(t, "Flag", "author", element.getAuthor(), -1); 11174 } 11175 } 11176 11177 protected void composeGoal(Complex parent, String parentType, String name, Goal element, int index) { 11178 if (element == null) 11179 return; 11180 Complex t; 11181 if (Utilities.noString(parentType)) 11182 t = parent; 11183 else { 11184 t = parent.predicate("fhir:"+parentType+'.'+name); 11185 } 11186 composeDomainResource(t, "Goal", name, element, index); 11187 for (int i = 0; i < element.getIdentifier().size(); i++) { 11188 composeIdentifier(t, "Goal", "identifier", element.getIdentifier().get(i), i); 11189 } 11190 if (element.hasLifecycleStatusElement()) { 11191 composeEnum(t, "Goal", "lifecycleStatus", element.getLifecycleStatusElement(), -1); 11192 } 11193 if (element.hasAchievementStatus()) { 11194 composeCodeableConcept(t, "Goal", "achievementStatus", element.getAchievementStatus(), -1); 11195 } 11196 for (int i = 0; i < element.getCategory().size(); i++) { 11197 composeCodeableConcept(t, "Goal", "category", element.getCategory().get(i), i); 11198 } 11199 if (element.hasContinuousElement()) { 11200 composeBoolean(t, "Goal", "continuous", element.getContinuousElement(), -1); 11201 } 11202 if (element.hasPriority()) { 11203 composeCodeableConcept(t, "Goal", "priority", element.getPriority(), -1); 11204 } 11205 if (element.hasDescription()) { 11206 composeCodeableConcept(t, "Goal", "description", element.getDescription(), -1); 11207 } 11208 if (element.hasSubject()) { 11209 composeReference(t, "Goal", "subject", element.getSubject(), -1); 11210 } 11211 if (element.hasStart()) { 11212 composeType(t, "Goal", "start", element.getStart(), -1); 11213 } 11214 for (int i = 0; i < element.getTarget().size(); i++) { 11215 composeGoalTargetComponent(t, "Goal", "target", element.getTarget().get(i), i); 11216 } 11217 if (element.hasStatusDateElement()) { 11218 composeDate(t, "Goal", "statusDate", element.getStatusDateElement(), -1); 11219 } 11220 if (element.hasStatusReasonElement()) { 11221 composeString(t, "Goal", "statusReason", element.getStatusReasonElement(), -1); 11222 } 11223 if (element.hasExpressedBy()) { 11224 composeReference(t, "Goal", "expressedBy", element.getExpressedBy(), -1); 11225 } 11226 for (int i = 0; i < element.getAddresses().size(); i++) { 11227 composeReference(t, "Goal", "addresses", element.getAddresses().get(i), i); 11228 } 11229 for (int i = 0; i < element.getNote().size(); i++) { 11230 composeAnnotation(t, "Goal", "note", element.getNote().get(i), i); 11231 } 11232 for (int i = 0; i < element.getOutcome().size(); i++) { 11233 composeCodeableReference(t, "Goal", "outcome", element.getOutcome().get(i), i); 11234 } 11235 } 11236 11237 protected void composeGoalTargetComponent(Complex parent, String parentType, String name, Goal.GoalTargetComponent element, int index) { 11238 if (element == null) 11239 return; 11240 Complex t; 11241 if (Utilities.noString(parentType)) 11242 t = parent; 11243 else { 11244 t = parent.predicate("fhir:"+parentType+'.'+name); 11245 } 11246 composeBackboneElement(t, "target", name, element, index); 11247 if (element.hasMeasure()) { 11248 composeCodeableConcept(t, "GoalTargetComponent", "measure", element.getMeasure(), -1); 11249 } 11250 if (element.hasDetail()) { 11251 composeType(t, "GoalTargetComponent", "detail", element.getDetail(), -1); 11252 } 11253 if (element.hasDue()) { 11254 composeType(t, "GoalTargetComponent", "due", element.getDue(), -1); 11255 } 11256 } 11257 11258 protected void composeGraphDefinition(Complex parent, String parentType, String name, GraphDefinition element, int index) { 11259 if (element == null) 11260 return; 11261 Complex t; 11262 if (Utilities.noString(parentType)) 11263 t = parent; 11264 else { 11265 t = parent.predicate("fhir:"+parentType+'.'+name); 11266 } 11267 composeCanonicalResource(t, "GraphDefinition", name, element, index); 11268 if (element.hasUrlElement()) { 11269 composeUri(t, "GraphDefinition", "url", element.getUrlElement(), -1); 11270 } 11271 if (element.hasVersionElement()) { 11272 composeString(t, "GraphDefinition", "version", element.getVersionElement(), -1); 11273 } 11274 if (element.hasNameElement()) { 11275 composeString(t, "GraphDefinition", "name", element.getNameElement(), -1); 11276 } 11277 if (element.hasStatusElement()) { 11278 composeEnum(t, "GraphDefinition", "status", element.getStatusElement(), -1); 11279 } 11280 if (element.hasExperimentalElement()) { 11281 composeBoolean(t, "GraphDefinition", "experimental", element.getExperimentalElement(), -1); 11282 } 11283 if (element.hasDateElement()) { 11284 composeDateTime(t, "GraphDefinition", "date", element.getDateElement(), -1); 11285 } 11286 if (element.hasPublisherElement()) { 11287 composeString(t, "GraphDefinition", "publisher", element.getPublisherElement(), -1); 11288 } 11289 for (int i = 0; i < element.getContact().size(); i++) { 11290 composeContactDetail(t, "GraphDefinition", "contact", element.getContact().get(i), i); 11291 } 11292 if (element.hasDescriptionElement()) { 11293 composeMarkdown(t, "GraphDefinition", "description", element.getDescriptionElement(), -1); 11294 } 11295 for (int i = 0; i < element.getUseContext().size(); i++) { 11296 composeUsageContext(t, "GraphDefinition", "useContext", element.getUseContext().get(i), i); 11297 } 11298 for (int i = 0; i < element.getJurisdiction().size(); i++) { 11299 composeCodeableConcept(t, "GraphDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 11300 } 11301 if (element.hasPurposeElement()) { 11302 composeMarkdown(t, "GraphDefinition", "purpose", element.getPurposeElement(), -1); 11303 } 11304 if (element.hasStartElement()) { 11305 composeCode(t, "GraphDefinition", "start", element.getStartElement(), -1); 11306 } 11307 if (element.hasProfileElement()) { 11308 composeCanonical(t, "GraphDefinition", "profile", element.getProfileElement(), -1); 11309 } 11310 for (int i = 0; i < element.getLink().size(); i++) { 11311 composeGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i); 11312 } 11313 } 11314 11315 protected void composeGraphDefinitionLinkComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkComponent element, int index) { 11316 if (element == null) 11317 return; 11318 Complex t; 11319 if (Utilities.noString(parentType)) 11320 t = parent; 11321 else { 11322 t = parent.predicate("fhir:"+parentType+'.'+name); 11323 } 11324 composeBackboneElement(t, "link", name, element, index); 11325 if (element.hasPathElement()) { 11326 composeString(t, "GraphDefinitionLinkComponent", "path", element.getPathElement(), -1); 11327 } 11328 if (element.hasSliceNameElement()) { 11329 composeString(t, "GraphDefinitionLinkComponent", "sliceName", element.getSliceNameElement(), -1); 11330 } 11331 if (element.hasMinElement()) { 11332 composeInteger(t, "GraphDefinitionLinkComponent", "min", element.getMinElement(), -1); 11333 } 11334 if (element.hasMaxElement()) { 11335 composeString(t, "GraphDefinitionLinkComponent", "max", element.getMaxElement(), -1); 11336 } 11337 if (element.hasDescriptionElement()) { 11338 composeString(t, "GraphDefinitionLinkComponent", "description", element.getDescriptionElement(), -1); 11339 } 11340 for (int i = 0; i < element.getTarget().size(); i++) { 11341 composeGraphDefinitionLinkTargetComponent(t, "GraphDefinitionLinkComponent", "target", element.getTarget().get(i), i); 11342 } 11343 } 11344 11345 protected void composeGraphDefinitionLinkTargetComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetComponent element, int index) { 11346 if (element == null) 11347 return; 11348 Complex t; 11349 if (Utilities.noString(parentType)) 11350 t = parent; 11351 else { 11352 t = parent.predicate("fhir:"+parentType+'.'+name); 11353 } 11354 composeBackboneElement(t, "target", name, element, index); 11355 if (element.hasTypeElement()) { 11356 composeCode(t, "GraphDefinitionLinkTargetComponent", "type", element.getTypeElement(), -1); 11357 } 11358 if (element.hasParamsElement()) { 11359 composeString(t, "GraphDefinitionLinkTargetComponent", "params", element.getParamsElement(), -1); 11360 } 11361 if (element.hasProfileElement()) { 11362 composeCanonical(t, "GraphDefinitionLinkTargetComponent", "profile", element.getProfileElement(), -1); 11363 } 11364 for (int i = 0; i < element.getCompartment().size(); i++) { 11365 composeGraphDefinitionLinkTargetCompartmentComponent(t, "GraphDefinitionLinkTargetComponent", "compartment", element.getCompartment().get(i), i); 11366 } 11367 for (int i = 0; i < element.getLink().size(); i++) { 11368 composeGraphDefinitionLinkComponent(t, "GraphDefinitionLinkTargetComponent", "link", element.getLink().get(i), i); 11369 } 11370 } 11371 11372 protected void composeGraphDefinitionLinkTargetCompartmentComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetCompartmentComponent element, int index) { 11373 if (element == null) 11374 return; 11375 Complex t; 11376 if (Utilities.noString(parentType)) 11377 t = parent; 11378 else { 11379 t = parent.predicate("fhir:"+parentType+'.'+name); 11380 } 11381 composeBackboneElement(t, "compartment", name, element, index); 11382 if (element.hasUseElement()) { 11383 composeEnum(t, "GraphDefinitionLinkTargetCompartmentComponent", "use", element.getUseElement(), -1); 11384 } 11385 if (element.hasCodeElement()) { 11386 composeEnum(t, "GraphDefinitionLinkTargetCompartmentComponent", "code", element.getCodeElement(), -1); 11387 } 11388 if (element.hasRuleElement()) { 11389 composeEnum(t, "GraphDefinitionLinkTargetCompartmentComponent", "rule", element.getRuleElement(), -1); 11390 } 11391 if (element.hasExpressionElement()) { 11392 composeString(t, "GraphDefinitionLinkTargetCompartmentComponent", "expression", element.getExpressionElement(), -1); 11393 } 11394 if (element.hasDescriptionElement()) { 11395 composeString(t, "GraphDefinitionLinkTargetCompartmentComponent", "description", element.getDescriptionElement(), -1); 11396 } 11397 } 11398 11399 protected void composeGroup(Complex parent, String parentType, String name, Group element, int index) { 11400 if (element == null) 11401 return; 11402 Complex t; 11403 if (Utilities.noString(parentType)) 11404 t = parent; 11405 else { 11406 t = parent.predicate("fhir:"+parentType+'.'+name); 11407 } 11408 composeDomainResource(t, "Group", name, element, index); 11409 for (int i = 0; i < element.getIdentifier().size(); i++) { 11410 composeIdentifier(t, "Group", "identifier", element.getIdentifier().get(i), i); 11411 } 11412 if (element.hasActiveElement()) { 11413 composeBoolean(t, "Group", "active", element.getActiveElement(), -1); 11414 } 11415 if (element.hasTypeElement()) { 11416 composeEnum(t, "Group", "type", element.getTypeElement(), -1); 11417 } 11418 if (element.hasActualElement()) { 11419 composeBoolean(t, "Group", "actual", element.getActualElement(), -1); 11420 } 11421 if (element.hasCode()) { 11422 composeCodeableConcept(t, "Group", "code", element.getCode(), -1); 11423 } 11424 if (element.hasNameElement()) { 11425 composeString(t, "Group", "name", element.getNameElement(), -1); 11426 } 11427 if (element.hasQuantityElement()) { 11428 composeUnsignedInt(t, "Group", "quantity", element.getQuantityElement(), -1); 11429 } 11430 if (element.hasManagingEntity()) { 11431 composeReference(t, "Group", "managingEntity", element.getManagingEntity(), -1); 11432 } 11433 for (int i = 0; i < element.getCharacteristic().size(); i++) { 11434 composeGroupCharacteristicComponent(t, "Group", "characteristic", element.getCharacteristic().get(i), i); 11435 } 11436 for (int i = 0; i < element.getMember().size(); i++) { 11437 composeGroupMemberComponent(t, "Group", "member", element.getMember().get(i), i); 11438 } 11439 } 11440 11441 protected void composeGroupCharacteristicComponent(Complex parent, String parentType, String name, Group.GroupCharacteristicComponent element, int index) { 11442 if (element == null) 11443 return; 11444 Complex t; 11445 if (Utilities.noString(parentType)) 11446 t = parent; 11447 else { 11448 t = parent.predicate("fhir:"+parentType+'.'+name); 11449 } 11450 composeBackboneElement(t, "characteristic", name, element, index); 11451 if (element.hasCode()) { 11452 composeCodeableConcept(t, "GroupCharacteristicComponent", "code", element.getCode(), -1); 11453 } 11454 if (element.hasValue()) { 11455 composeType(t, "GroupCharacteristicComponent", "value", element.getValue(), -1); 11456 } 11457 if (element.hasExcludeElement()) { 11458 composeBoolean(t, "GroupCharacteristicComponent", "exclude", element.getExcludeElement(), -1); 11459 } 11460 if (element.hasPeriod()) { 11461 composePeriod(t, "GroupCharacteristicComponent", "period", element.getPeriod(), -1); 11462 } 11463 } 11464 11465 protected void composeGroupMemberComponent(Complex parent, String parentType, String name, Group.GroupMemberComponent element, int index) { 11466 if (element == null) 11467 return; 11468 Complex t; 11469 if (Utilities.noString(parentType)) 11470 t = parent; 11471 else { 11472 t = parent.predicate("fhir:"+parentType+'.'+name); 11473 } 11474 composeBackboneElement(t, "member", name, element, index); 11475 if (element.hasEntity()) { 11476 composeReference(t, "GroupMemberComponent", "entity", element.getEntity(), -1); 11477 } 11478 if (element.hasPeriod()) { 11479 composePeriod(t, "GroupMemberComponent", "period", element.getPeriod(), -1); 11480 } 11481 if (element.hasInactiveElement()) { 11482 composeBoolean(t, "GroupMemberComponent", "inactive", element.getInactiveElement(), -1); 11483 } 11484 } 11485 11486 protected void composeGuidanceResponse(Complex parent, String parentType, String name, GuidanceResponse element, int index) { 11487 if (element == null) 11488 return; 11489 Complex t; 11490 if (Utilities.noString(parentType)) 11491 t = parent; 11492 else { 11493 t = parent.predicate("fhir:"+parentType+'.'+name); 11494 } 11495 composeDomainResource(t, "GuidanceResponse", name, element, index); 11496 if (element.hasRequestIdentifier()) { 11497 composeIdentifier(t, "GuidanceResponse", "requestIdentifier", element.getRequestIdentifier(), -1); 11498 } 11499 for (int i = 0; i < element.getIdentifier().size(); i++) { 11500 composeIdentifier(t, "GuidanceResponse", "identifier", element.getIdentifier().get(i), i); 11501 } 11502 if (element.hasModule()) { 11503 composeType(t, "GuidanceResponse", "module", element.getModule(), -1); 11504 } 11505 if (element.hasStatusElement()) { 11506 composeEnum(t, "GuidanceResponse", "status", element.getStatusElement(), -1); 11507 } 11508 if (element.hasSubject()) { 11509 composeReference(t, "GuidanceResponse", "subject", element.getSubject(), -1); 11510 } 11511 if (element.hasEncounter()) { 11512 composeReference(t, "GuidanceResponse", "encounter", element.getEncounter(), -1); 11513 } 11514 if (element.hasOccurrenceDateTimeElement()) { 11515 composeDateTime(t, "GuidanceResponse", "occurrenceDateTime", element.getOccurrenceDateTimeElement(), -1); 11516 } 11517 if (element.hasPerformer()) { 11518 composeReference(t, "GuidanceResponse", "performer", element.getPerformer(), -1); 11519 } 11520 for (int i = 0; i < element.getReason().size(); i++) { 11521 composeCodeableReference(t, "GuidanceResponse", "reason", element.getReason().get(i), i); 11522 } 11523 for (int i = 0; i < element.getNote().size(); i++) { 11524 composeAnnotation(t, "GuidanceResponse", "note", element.getNote().get(i), i); 11525 } 11526 for (int i = 0; i < element.getEvaluationMessage().size(); i++) { 11527 composeReference(t, "GuidanceResponse", "evaluationMessage", element.getEvaluationMessage().get(i), i); 11528 } 11529 if (element.hasOutputParameters()) { 11530 composeReference(t, "GuidanceResponse", "outputParameters", element.getOutputParameters(), -1); 11531 } 11532 if (element.hasResult()) { 11533 composeReference(t, "GuidanceResponse", "result", element.getResult(), -1); 11534 } 11535 for (int i = 0; i < element.getDataRequirement().size(); i++) { 11536 composeDataRequirement(t, "GuidanceResponse", "dataRequirement", element.getDataRequirement().get(i), i); 11537 } 11538 } 11539 11540 protected void composeHealthcareService(Complex parent, String parentType, String name, HealthcareService element, int index) { 11541 if (element == null) 11542 return; 11543 Complex t; 11544 if (Utilities.noString(parentType)) 11545 t = parent; 11546 else { 11547 t = parent.predicate("fhir:"+parentType+'.'+name); 11548 } 11549 composeDomainResource(t, "HealthcareService", name, element, index); 11550 for (int i = 0; i < element.getIdentifier().size(); i++) { 11551 composeIdentifier(t, "HealthcareService", "identifier", element.getIdentifier().get(i), i); 11552 } 11553 if (element.hasActiveElement()) { 11554 composeBoolean(t, "HealthcareService", "active", element.getActiveElement(), -1); 11555 } 11556 if (element.hasProvidedBy()) { 11557 composeReference(t, "HealthcareService", "providedBy", element.getProvidedBy(), -1); 11558 } 11559 for (int i = 0; i < element.getCategory().size(); i++) { 11560 composeCodeableConcept(t, "HealthcareService", "category", element.getCategory().get(i), i); 11561 } 11562 for (int i = 0; i < element.getType().size(); i++) { 11563 composeCodeableConcept(t, "HealthcareService", "type", element.getType().get(i), i); 11564 } 11565 for (int i = 0; i < element.getSpecialty().size(); i++) { 11566 composeCodeableConcept(t, "HealthcareService", "specialty", element.getSpecialty().get(i), i); 11567 } 11568 for (int i = 0; i < element.getLocation().size(); i++) { 11569 composeReference(t, "HealthcareService", "location", element.getLocation().get(i), i); 11570 } 11571 if (element.hasNameElement()) { 11572 composeString(t, "HealthcareService", "name", element.getNameElement(), -1); 11573 } 11574 if (element.hasCommentElement()) { 11575 composeString(t, "HealthcareService", "comment", element.getCommentElement(), -1); 11576 } 11577 if (element.hasExtraDetailsElement()) { 11578 composeMarkdown(t, "HealthcareService", "extraDetails", element.getExtraDetailsElement(), -1); 11579 } 11580 if (element.hasPhoto()) { 11581 composeAttachment(t, "HealthcareService", "photo", element.getPhoto(), -1); 11582 } 11583 for (int i = 0; i < element.getTelecom().size(); i++) { 11584 composeContactPoint(t, "HealthcareService", "telecom", element.getTelecom().get(i), i); 11585 } 11586 for (int i = 0; i < element.getCoverageArea().size(); i++) { 11587 composeReference(t, "HealthcareService", "coverageArea", element.getCoverageArea().get(i), i); 11588 } 11589 for (int i = 0; i < element.getServiceProvisionCode().size(); i++) { 11590 composeCodeableConcept(t, "HealthcareService", "serviceProvisionCode", element.getServiceProvisionCode().get(i), i); 11591 } 11592 for (int i = 0; i < element.getEligibility().size(); i++) { 11593 composeHealthcareServiceEligibilityComponent(t, "HealthcareService", "eligibility", element.getEligibility().get(i), i); 11594 } 11595 for (int i = 0; i < element.getProgram().size(); i++) { 11596 composeCodeableConcept(t, "HealthcareService", "program", element.getProgram().get(i), i); 11597 } 11598 for (int i = 0; i < element.getCharacteristic().size(); i++) { 11599 composeCodeableConcept(t, "HealthcareService", "characteristic", element.getCharacteristic().get(i), i); 11600 } 11601 for (int i = 0; i < element.getCommunication().size(); i++) { 11602 composeCodeableConcept(t, "HealthcareService", "communication", element.getCommunication().get(i), i); 11603 } 11604 for (int i = 0; i < element.getReferralMethod().size(); i++) { 11605 composeCodeableConcept(t, "HealthcareService", "referralMethod", element.getReferralMethod().get(i), i); 11606 } 11607 if (element.hasAppointmentRequiredElement()) { 11608 composeBoolean(t, "HealthcareService", "appointmentRequired", element.getAppointmentRequiredElement(), -1); 11609 } 11610 for (int i = 0; i < element.getAvailableTime().size(); i++) { 11611 composeHealthcareServiceAvailableTimeComponent(t, "HealthcareService", "availableTime", element.getAvailableTime().get(i), i); 11612 } 11613 for (int i = 0; i < element.getNotAvailable().size(); i++) { 11614 composeHealthcareServiceNotAvailableComponent(t, "HealthcareService", "notAvailable", element.getNotAvailable().get(i), i); 11615 } 11616 if (element.hasAvailabilityExceptionsElement()) { 11617 composeString(t, "HealthcareService", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1); 11618 } 11619 for (int i = 0; i < element.getEndpoint().size(); i++) { 11620 composeReference(t, "HealthcareService", "endpoint", element.getEndpoint().get(i), i); 11621 } 11622 } 11623 11624 protected void composeHealthcareServiceEligibilityComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceEligibilityComponent element, int index) { 11625 if (element == null) 11626 return; 11627 Complex t; 11628 if (Utilities.noString(parentType)) 11629 t = parent; 11630 else { 11631 t = parent.predicate("fhir:"+parentType+'.'+name); 11632 } 11633 composeBackboneElement(t, "eligibility", name, element, index); 11634 if (element.hasCode()) { 11635 composeCodeableConcept(t, "HealthcareServiceEligibilityComponent", "code", element.getCode(), -1); 11636 } 11637 if (element.hasCommentElement()) { 11638 composeMarkdown(t, "HealthcareServiceEligibilityComponent", "comment", element.getCommentElement(), -1); 11639 } 11640 } 11641 11642 protected void composeHealthcareServiceAvailableTimeComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceAvailableTimeComponent 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, "availableTime", name, element, index); 11652 for (int i = 0; i < element.getDaysOfWeek().size(); i++) { 11653 composeEnum(t, "HealthcareServiceAvailableTimeComponent", "daysOfWeek", element.getDaysOfWeek().get(i), i); 11654 } 11655 if (element.hasAllDayElement()) { 11656 composeBoolean(t, "HealthcareServiceAvailableTimeComponent", "allDay", element.getAllDayElement(), -1); 11657 } 11658 if (element.hasAvailableStartTimeElement()) { 11659 composeTime(t, "HealthcareServiceAvailableTimeComponent", "availableStartTime", element.getAvailableStartTimeElement(), -1); 11660 } 11661 if (element.hasAvailableEndTimeElement()) { 11662 composeTime(t, "HealthcareServiceAvailableTimeComponent", "availableEndTime", element.getAvailableEndTimeElement(), -1); 11663 } 11664 } 11665 11666 protected void composeHealthcareServiceNotAvailableComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceNotAvailableComponent element, int index) { 11667 if (element == null) 11668 return; 11669 Complex t; 11670 if (Utilities.noString(parentType)) 11671 t = parent; 11672 else { 11673 t = parent.predicate("fhir:"+parentType+'.'+name); 11674 } 11675 composeBackboneElement(t, "notAvailable", name, element, index); 11676 if (element.hasDescriptionElement()) { 11677 composeString(t, "HealthcareServiceNotAvailableComponent", "description", element.getDescriptionElement(), -1); 11678 } 11679 if (element.hasDuring()) { 11680 composePeriod(t, "HealthcareServiceNotAvailableComponent", "during", element.getDuring(), -1); 11681 } 11682 } 11683 11684 protected void composeImagingStudy(Complex parent, String parentType, String name, ImagingStudy 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 composeDomainResource(t, "ImagingStudy", name, element, index); 11694 for (int i = 0; i < element.getIdentifier().size(); i++) { 11695 composeIdentifier(t, "ImagingStudy", "identifier", element.getIdentifier().get(i), i); 11696 } 11697 if (element.hasStatusElement()) { 11698 composeEnum(t, "ImagingStudy", "status", element.getStatusElement(), -1); 11699 } 11700 for (int i = 0; i < element.getModality().size(); i++) { 11701 composeCoding(t, "ImagingStudy", "modality", element.getModality().get(i), i); 11702 } 11703 if (element.hasSubject()) { 11704 composeReference(t, "ImagingStudy", "subject", element.getSubject(), -1); 11705 } 11706 if (element.hasEncounter()) { 11707 composeReference(t, "ImagingStudy", "encounter", element.getEncounter(), -1); 11708 } 11709 if (element.hasStartedElement()) { 11710 composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1); 11711 } 11712 for (int i = 0; i < element.getBasedOn().size(); i++) { 11713 composeReference(t, "ImagingStudy", "basedOn", element.getBasedOn().get(i), i); 11714 } 11715 if (element.hasReferrer()) { 11716 composeReference(t, "ImagingStudy", "referrer", element.getReferrer(), -1); 11717 } 11718 for (int i = 0; i < element.getInterpreter().size(); i++) { 11719 composeReference(t, "ImagingStudy", "interpreter", element.getInterpreter().get(i), i); 11720 } 11721 for (int i = 0; i < element.getEndpoint().size(); i++) { 11722 composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i); 11723 } 11724 if (element.hasNumberOfSeriesElement()) { 11725 composeUnsignedInt(t, "ImagingStudy", "numberOfSeries", element.getNumberOfSeriesElement(), -1); 11726 } 11727 if (element.hasNumberOfInstancesElement()) { 11728 composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1); 11729 } 11730 for (int i = 0; i < element.getProcedure().size(); i++) { 11731 composeImagingStudyProcedureComponent(t, "ImagingStudy", "procedure", element.getProcedure().get(i), i); 11732 } 11733 if (element.hasLocation()) { 11734 composeReference(t, "ImagingStudy", "location", element.getLocation(), -1); 11735 } 11736 for (int i = 0; i < element.getReason().size(); i++) { 11737 composeCodeableReference(t, "ImagingStudy", "reason", element.getReason().get(i), i); 11738 } 11739 for (int i = 0; i < element.getNote().size(); i++) { 11740 composeAnnotation(t, "ImagingStudy", "note", element.getNote().get(i), i); 11741 } 11742 if (element.hasDescriptionElement()) { 11743 composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1); 11744 } 11745 for (int i = 0; i < element.getSeries().size(); i++) { 11746 composeImagingStudySeriesComponent(t, "ImagingStudy", "series", element.getSeries().get(i), i); 11747 } 11748 } 11749 11750 protected void composeImagingStudyProcedureComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudyProcedureComponent element, int index) { 11751 if (element == null) 11752 return; 11753 Complex t; 11754 if (Utilities.noString(parentType)) 11755 t = parent; 11756 else { 11757 t = parent.predicate("fhir:"+parentType+'.'+name); 11758 } 11759 composeBackboneElement(t, "procedure", name, element, index); 11760 if (element.hasValue()) { 11761 composeType(t, "ImagingStudyProcedureComponent", "value", element.getValue(), -1); 11762 } 11763 } 11764 11765 protected void composeImagingStudySeriesComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesComponent element, int index) { 11766 if (element == null) 11767 return; 11768 Complex t; 11769 if (Utilities.noString(parentType)) 11770 t = parent; 11771 else { 11772 t = parent.predicate("fhir:"+parentType+'.'+name); 11773 } 11774 composeBackboneElement(t, "series", name, element, index); 11775 if (element.hasUidElement()) { 11776 composeId(t, "ImagingStudySeriesComponent", "uid", element.getUidElement(), -1); 11777 } 11778 if (element.hasNumberElement()) { 11779 composeUnsignedInt(t, "ImagingStudySeriesComponent", "number", element.getNumberElement(), -1); 11780 } 11781 if (element.hasModality()) { 11782 composeCoding(t, "ImagingStudySeriesComponent", "modality", element.getModality(), -1); 11783 } 11784 if (element.hasDescriptionElement()) { 11785 composeString(t, "ImagingStudySeriesComponent", "description", element.getDescriptionElement(), -1); 11786 } 11787 if (element.hasNumberOfInstancesElement()) { 11788 composeUnsignedInt(t, "ImagingStudySeriesComponent", "numberOfInstances", element.getNumberOfInstancesElement(), -1); 11789 } 11790 for (int i = 0; i < element.getEndpoint().size(); i++) { 11791 composeReference(t, "ImagingStudySeriesComponent", "endpoint", element.getEndpoint().get(i), i); 11792 } 11793 if (element.hasBodySite()) { 11794 composeCoding(t, "ImagingStudySeriesComponent", "bodySite", element.getBodySite(), -1); 11795 } 11796 if (element.hasLaterality()) { 11797 composeCoding(t, "ImagingStudySeriesComponent", "laterality", element.getLaterality(), -1); 11798 } 11799 for (int i = 0; i < element.getSpecimen().size(); i++) { 11800 composeReference(t, "ImagingStudySeriesComponent", "specimen", element.getSpecimen().get(i), i); 11801 } 11802 if (element.hasStartedElement()) { 11803 composeDateTime(t, "ImagingStudySeriesComponent", "started", element.getStartedElement(), -1); 11804 } 11805 for (int i = 0; i < element.getPerformer().size(); i++) { 11806 composeImagingStudySeriesPerformerComponent(t, "ImagingStudySeriesComponent", "performer", element.getPerformer().get(i), i); 11807 } 11808 for (int i = 0; i < element.getInstance().size(); i++) { 11809 composeImagingStudySeriesInstanceComponent(t, "ImagingStudySeriesComponent", "instance", element.getInstance().get(i), i); 11810 } 11811 } 11812 11813 protected void composeImagingStudySeriesPerformerComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesPerformerComponent element, int index) { 11814 if (element == null) 11815 return; 11816 Complex t; 11817 if (Utilities.noString(parentType)) 11818 t = parent; 11819 else { 11820 t = parent.predicate("fhir:"+parentType+'.'+name); 11821 } 11822 composeBackboneElement(t, "performer", name, element, index); 11823 if (element.hasFunction()) { 11824 composeCodeableConcept(t, "ImagingStudySeriesPerformerComponent", "function", element.getFunction(), -1); 11825 } 11826 if (element.hasActor()) { 11827 composeReference(t, "ImagingStudySeriesPerformerComponent", "actor", element.getActor(), -1); 11828 } 11829 } 11830 11831 protected void composeImagingStudySeriesInstanceComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesInstanceComponent element, int index) { 11832 if (element == null) 11833 return; 11834 Complex t; 11835 if (Utilities.noString(parentType)) 11836 t = parent; 11837 else { 11838 t = parent.predicate("fhir:"+parentType+'.'+name); 11839 } 11840 composeBackboneElement(t, "instance", name, element, index); 11841 if (element.hasUidElement()) { 11842 composeId(t, "ImagingStudySeriesInstanceComponent", "uid", element.getUidElement(), -1); 11843 } 11844 if (element.hasSopClass()) { 11845 composeCoding(t, "ImagingStudySeriesInstanceComponent", "sopClass", element.getSopClass(), -1); 11846 } 11847 if (element.hasNumberElement()) { 11848 composeUnsignedInt(t, "ImagingStudySeriesInstanceComponent", "number", element.getNumberElement(), -1); 11849 } 11850 if (element.hasTitleElement()) { 11851 composeString(t, "ImagingStudySeriesInstanceComponent", "title", element.getTitleElement(), -1); 11852 } 11853 } 11854 11855 protected void composeImmunization(Complex parent, String parentType, String name, Immunization element, int index) { 11856 if (element == null) 11857 return; 11858 Complex t; 11859 if (Utilities.noString(parentType)) 11860 t = parent; 11861 else { 11862 t = parent.predicate("fhir:"+parentType+'.'+name); 11863 } 11864 composeDomainResource(t, "Immunization", name, element, index); 11865 for (int i = 0; i < element.getIdentifier().size(); i++) { 11866 composeIdentifier(t, "Immunization", "identifier", element.getIdentifier().get(i), i); 11867 } 11868 if (element.hasStatusElement()) { 11869 composeEnum(t, "Immunization", "status", element.getStatusElement(), -1); 11870 } 11871 if (element.hasStatusReason()) { 11872 composeCodeableConcept(t, "Immunization", "statusReason", element.getStatusReason(), -1); 11873 } 11874 if (element.hasVaccineCode()) { 11875 composeCodeableConcept(t, "Immunization", "vaccineCode", element.getVaccineCode(), -1); 11876 } 11877 if (element.hasPatient()) { 11878 composeReference(t, "Immunization", "patient", element.getPatient(), -1); 11879 } 11880 if (element.hasEncounter()) { 11881 composeReference(t, "Immunization", "encounter", element.getEncounter(), -1); 11882 } 11883 if (element.hasOccurrence()) { 11884 composeType(t, "Immunization", "occurrence", element.getOccurrence(), -1); 11885 } 11886 if (element.hasRecordedElement()) { 11887 composeDateTime(t, "Immunization", "recorded", element.getRecordedElement(), -1); 11888 } 11889 if (element.hasPrimarySourceElement()) { 11890 composeBoolean(t, "Immunization", "primarySource", element.getPrimarySourceElement(), -1); 11891 } 11892 if (element.hasInformationSource()) { 11893 composeType(t, "Immunization", "informationSource", element.getInformationSource(), -1); 11894 } 11895 if (element.hasLocation()) { 11896 composeReference(t, "Immunization", "location", element.getLocation(), -1); 11897 } 11898 if (element.hasManufacturer()) { 11899 composeReference(t, "Immunization", "manufacturer", element.getManufacturer(), -1); 11900 } 11901 if (element.hasLotNumberElement()) { 11902 composeString(t, "Immunization", "lotNumber", element.getLotNumberElement(), -1); 11903 } 11904 if (element.hasExpirationDateElement()) { 11905 composeDate(t, "Immunization", "expirationDate", element.getExpirationDateElement(), -1); 11906 } 11907 if (element.hasSite()) { 11908 composeCodeableConcept(t, "Immunization", "site", element.getSite(), -1); 11909 } 11910 if (element.hasRoute()) { 11911 composeCodeableConcept(t, "Immunization", "route", element.getRoute(), -1); 11912 } 11913 if (element.hasDoseQuantity()) { 11914 composeQuantity(t, "Immunization", "doseQuantity", element.getDoseQuantity(), -1); 11915 } 11916 for (int i = 0; i < element.getPerformer().size(); i++) { 11917 composeImmunizationPerformerComponent(t, "Immunization", "performer", element.getPerformer().get(i), i); 11918 } 11919 for (int i = 0; i < element.getNote().size(); i++) { 11920 composeAnnotation(t, "Immunization", "note", element.getNote().get(i), i); 11921 } 11922 for (int i = 0; i < element.getReason().size(); i++) { 11923 composeCodeableReference(t, "Immunization", "reason", element.getReason().get(i), i); 11924 } 11925 if (element.hasIsSubpotentElement()) { 11926 composeBoolean(t, "Immunization", "isSubpotent", element.getIsSubpotentElement(), -1); 11927 } 11928 for (int i = 0; i < element.getSubpotentReason().size(); i++) { 11929 composeCodeableConcept(t, "Immunization", "subpotentReason", element.getSubpotentReason().get(i), i); 11930 } 11931 for (int i = 0; i < element.getEducation().size(); i++) { 11932 composeImmunizationEducationComponent(t, "Immunization", "education", element.getEducation().get(i), i); 11933 } 11934 for (int i = 0; i < element.getProgramEligibility().size(); i++) { 11935 composeCodeableConcept(t, "Immunization", "programEligibility", element.getProgramEligibility().get(i), i); 11936 } 11937 if (element.hasFundingSource()) { 11938 composeCodeableConcept(t, "Immunization", "fundingSource", element.getFundingSource(), -1); 11939 } 11940 for (int i = 0; i < element.getReaction().size(); i++) { 11941 composeImmunizationReactionComponent(t, "Immunization", "reaction", element.getReaction().get(i), i); 11942 } 11943 for (int i = 0; i < element.getProtocolApplied().size(); i++) { 11944 composeImmunizationProtocolAppliedComponent(t, "Immunization", "protocolApplied", element.getProtocolApplied().get(i), i); 11945 } 11946 } 11947 11948 protected void composeImmunizationPerformerComponent(Complex parent, String parentType, String name, Immunization.ImmunizationPerformerComponent element, int index) { 11949 if (element == null) 11950 return; 11951 Complex t; 11952 if (Utilities.noString(parentType)) 11953 t = parent; 11954 else { 11955 t = parent.predicate("fhir:"+parentType+'.'+name); 11956 } 11957 composeBackboneElement(t, "performer", name, element, index); 11958 if (element.hasFunction()) { 11959 composeCodeableConcept(t, "ImmunizationPerformerComponent", "function", element.getFunction(), -1); 11960 } 11961 if (element.hasActor()) { 11962 composeReference(t, "ImmunizationPerformerComponent", "actor", element.getActor(), -1); 11963 } 11964 } 11965 11966 protected void composeImmunizationEducationComponent(Complex parent, String parentType, String name, Immunization.ImmunizationEducationComponent element, int index) { 11967 if (element == null) 11968 return; 11969 Complex t; 11970 if (Utilities.noString(parentType)) 11971 t = parent; 11972 else { 11973 t = parent.predicate("fhir:"+parentType+'.'+name); 11974 } 11975 composeBackboneElement(t, "education", name, element, index); 11976 if (element.hasDocumentTypeElement()) { 11977 composeString(t, "ImmunizationEducationComponent", "documentType", element.getDocumentTypeElement(), -1); 11978 } 11979 if (element.hasReferenceElement()) { 11980 composeUri(t, "ImmunizationEducationComponent", "reference", element.getReferenceElement(), -1); 11981 } 11982 if (element.hasPublicationDateElement()) { 11983 composeDateTime(t, "ImmunizationEducationComponent", "publicationDate", element.getPublicationDateElement(), -1); 11984 } 11985 if (element.hasPresentationDateElement()) { 11986 composeDateTime(t, "ImmunizationEducationComponent", "presentationDate", element.getPresentationDateElement(), -1); 11987 } 11988 } 11989 11990 protected void composeImmunizationReactionComponent(Complex parent, String parentType, String name, Immunization.ImmunizationReactionComponent element, int index) { 11991 if (element == null) 11992 return; 11993 Complex t; 11994 if (Utilities.noString(parentType)) 11995 t = parent; 11996 else { 11997 t = parent.predicate("fhir:"+parentType+'.'+name); 11998 } 11999 composeBackboneElement(t, "reaction", name, element, index); 12000 if (element.hasDateElement()) { 12001 composeDateTime(t, "ImmunizationReactionComponent", "date", element.getDateElement(), -1); 12002 } 12003 if (element.hasDetail()) { 12004 composeReference(t, "ImmunizationReactionComponent", "detail", element.getDetail(), -1); 12005 } 12006 if (element.hasReportedElement()) { 12007 composeBoolean(t, "ImmunizationReactionComponent", "reported", element.getReportedElement(), -1); 12008 } 12009 } 12010 12011 protected void composeImmunizationProtocolAppliedComponent(Complex parent, String parentType, String name, Immunization.ImmunizationProtocolAppliedComponent element, int index) { 12012 if (element == null) 12013 return; 12014 Complex t; 12015 if (Utilities.noString(parentType)) 12016 t = parent; 12017 else { 12018 t = parent.predicate("fhir:"+parentType+'.'+name); 12019 } 12020 composeBackboneElement(t, "protocolApplied", name, element, index); 12021 if (element.hasSeriesElement()) { 12022 composeString(t, "ImmunizationProtocolAppliedComponent", "series", element.getSeriesElement(), -1); 12023 } 12024 if (element.hasAuthority()) { 12025 composeReference(t, "ImmunizationProtocolAppliedComponent", "authority", element.getAuthority(), -1); 12026 } 12027 for (int i = 0; i < element.getTargetDisease().size(); i++) { 12028 composeCodeableConcept(t, "ImmunizationProtocolAppliedComponent", "targetDisease", element.getTargetDisease().get(i), i); 12029 } 12030 if (element.hasDoseNumber()) { 12031 composeType(t, "ImmunizationProtocolAppliedComponent", "doseNumber", element.getDoseNumber(), -1); 12032 } 12033 if (element.hasSeriesDoses()) { 12034 composeType(t, "ImmunizationProtocolAppliedComponent", "seriesDoses", element.getSeriesDoses(), -1); 12035 } 12036 } 12037 12038 protected void composeImmunizationEvaluation(Complex parent, String parentType, String name, ImmunizationEvaluation element, int index) { 12039 if (element == null) 12040 return; 12041 Complex t; 12042 if (Utilities.noString(parentType)) 12043 t = parent; 12044 else { 12045 t = parent.predicate("fhir:"+parentType+'.'+name); 12046 } 12047 composeDomainResource(t, "ImmunizationEvaluation", name, element, index); 12048 for (int i = 0; i < element.getIdentifier().size(); i++) { 12049 composeIdentifier(t, "ImmunizationEvaluation", "identifier", element.getIdentifier().get(i), i); 12050 } 12051 if (element.hasStatusElement()) { 12052 composeEnum(t, "ImmunizationEvaluation", "status", element.getStatusElement(), -1); 12053 } 12054 if (element.hasPatient()) { 12055 composeReference(t, "ImmunizationEvaluation", "patient", element.getPatient(), -1); 12056 } 12057 if (element.hasDateElement()) { 12058 composeDateTime(t, "ImmunizationEvaluation", "date", element.getDateElement(), -1); 12059 } 12060 if (element.hasAuthority()) { 12061 composeReference(t, "ImmunizationEvaluation", "authority", element.getAuthority(), -1); 12062 } 12063 if (element.hasTargetDisease()) { 12064 composeCodeableConcept(t, "ImmunizationEvaluation", "targetDisease", element.getTargetDisease(), -1); 12065 } 12066 if (element.hasImmunizationEvent()) { 12067 composeReference(t, "ImmunizationEvaluation", "immunizationEvent", element.getImmunizationEvent(), -1); 12068 } 12069 if (element.hasDoseStatus()) { 12070 composeCodeableConcept(t, "ImmunizationEvaluation", "doseStatus", element.getDoseStatus(), -1); 12071 } 12072 for (int i = 0; i < element.getDoseStatusReason().size(); i++) { 12073 composeCodeableConcept(t, "ImmunizationEvaluation", "doseStatusReason", element.getDoseStatusReason().get(i), i); 12074 } 12075 if (element.hasDescriptionElement()) { 12076 composeString(t, "ImmunizationEvaluation", "description", element.getDescriptionElement(), -1); 12077 } 12078 if (element.hasSeriesElement()) { 12079 composeString(t, "ImmunizationEvaluation", "series", element.getSeriesElement(), -1); 12080 } 12081 if (element.hasDoseNumber()) { 12082 composeType(t, "ImmunizationEvaluation", "doseNumber", element.getDoseNumber(), -1); 12083 } 12084 if (element.hasSeriesDoses()) { 12085 composeType(t, "ImmunizationEvaluation", "seriesDoses", element.getSeriesDoses(), -1); 12086 } 12087 } 12088 12089 protected void composeImmunizationRecommendation(Complex parent, String parentType, String name, ImmunizationRecommendation element, int index) { 12090 if (element == null) 12091 return; 12092 Complex t; 12093 if (Utilities.noString(parentType)) 12094 t = parent; 12095 else { 12096 t = parent.predicate("fhir:"+parentType+'.'+name); 12097 } 12098 composeDomainResource(t, "ImmunizationRecommendation", name, element, index); 12099 for (int i = 0; i < element.getIdentifier().size(); i++) { 12100 composeIdentifier(t, "ImmunizationRecommendation", "identifier", element.getIdentifier().get(i), i); 12101 } 12102 if (element.hasPatient()) { 12103 composeReference(t, "ImmunizationRecommendation", "patient", element.getPatient(), -1); 12104 } 12105 if (element.hasDateElement()) { 12106 composeDateTime(t, "ImmunizationRecommendation", "date", element.getDateElement(), -1); 12107 } 12108 if (element.hasAuthority()) { 12109 composeReference(t, "ImmunizationRecommendation", "authority", element.getAuthority(), -1); 12110 } 12111 for (int i = 0; i < element.getRecommendation().size(); i++) { 12112 composeImmunizationRecommendationRecommendationComponent(t, "ImmunizationRecommendation", "recommendation", element.getRecommendation().get(i), i); 12113 } 12114 } 12115 12116 protected void composeImmunizationRecommendationRecommendationComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent element, int index) { 12117 if (element == null) 12118 return; 12119 Complex t; 12120 if (Utilities.noString(parentType)) 12121 t = parent; 12122 else { 12123 t = parent.predicate("fhir:"+parentType+'.'+name); 12124 } 12125 composeBackboneElement(t, "recommendation", name, element, index); 12126 for (int i = 0; i < element.getVaccineCode().size(); i++) { 12127 composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "vaccineCode", element.getVaccineCode().get(i), i); 12128 } 12129 for (int i = 0; i < element.getTargetDisease().size(); i++) { 12130 composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "targetDisease", element.getTargetDisease().get(i), i); 12131 } 12132 for (int i = 0; i < element.getContraindicatedVaccineCode().size(); i++) { 12133 composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "contraindicatedVaccineCode", element.getContraindicatedVaccineCode().get(i), i); 12134 } 12135 if (element.hasForecastStatus()) { 12136 composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "forecastStatus", element.getForecastStatus(), -1); 12137 } 12138 for (int i = 0; i < element.getForecastReason().size(); i++) { 12139 composeCodeableConcept(t, "ImmunizationRecommendationRecommendationComponent", "forecastReason", element.getForecastReason().get(i), i); 12140 } 12141 for (int i = 0; i < element.getDateCriterion().size(); i++) { 12142 composeImmunizationRecommendationRecommendationDateCriterionComponent(t, "ImmunizationRecommendationRecommendationComponent", "dateCriterion", element.getDateCriterion().get(i), i); 12143 } 12144 if (element.hasDescriptionElement()) { 12145 composeString(t, "ImmunizationRecommendationRecommendationComponent", "description", element.getDescriptionElement(), -1); 12146 } 12147 if (element.hasSeriesElement()) { 12148 composeString(t, "ImmunizationRecommendationRecommendationComponent", "series", element.getSeriesElement(), -1); 12149 } 12150 if (element.hasDoseNumber()) { 12151 composeType(t, "ImmunizationRecommendationRecommendationComponent", "doseNumber", element.getDoseNumber(), -1); 12152 } 12153 if (element.hasSeriesDoses()) { 12154 composeType(t, "ImmunizationRecommendationRecommendationComponent", "seriesDoses", element.getSeriesDoses(), -1); 12155 } 12156 for (int i = 0; i < element.getSupportingImmunization().size(); i++) { 12157 composeReference(t, "ImmunizationRecommendationRecommendationComponent", "supportingImmunization", element.getSupportingImmunization().get(i), i); 12158 } 12159 for (int i = 0; i < element.getSupportingPatientInformation().size(); i++) { 12160 composeReference(t, "ImmunizationRecommendationRecommendationComponent", "supportingPatientInformation", element.getSupportingPatientInformation().get(i), i); 12161 } 12162 } 12163 12164 protected void composeImmunizationRecommendationRecommendationDateCriterionComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent element, int index) { 12165 if (element == null) 12166 return; 12167 Complex t; 12168 if (Utilities.noString(parentType)) 12169 t = parent; 12170 else { 12171 t = parent.predicate("fhir:"+parentType+'.'+name); 12172 } 12173 composeBackboneElement(t, "dateCriterion", name, element, index); 12174 if (element.hasCode()) { 12175 composeCodeableConcept(t, "ImmunizationRecommendationRecommendationDateCriterionComponent", "code", element.getCode(), -1); 12176 } 12177 if (element.hasValueElement()) { 12178 composeDateTime(t, "ImmunizationRecommendationRecommendationDateCriterionComponent", "value", element.getValueElement(), -1); 12179 } 12180 } 12181 12182 protected void composeImplementationGuide(Complex parent, String parentType, String name, ImplementationGuide element, int index) { 12183 if (element == null) 12184 return; 12185 Complex t; 12186 if (Utilities.noString(parentType)) 12187 t = parent; 12188 else { 12189 t = parent.predicate("fhir:"+parentType+'.'+name); 12190 } 12191 composeCanonicalResource(t, "ImplementationGuide", name, element, index); 12192 if (element.hasUrlElement()) { 12193 composeUri(t, "ImplementationGuide", "url", element.getUrlElement(), -1); 12194 } 12195 if (element.hasVersionElement()) { 12196 composeString(t, "ImplementationGuide", "version", element.getVersionElement(), -1); 12197 } 12198 if (element.hasNameElement()) { 12199 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 12200 } 12201 if (element.hasTitleElement()) { 12202 composeString(t, "ImplementationGuide", "title", element.getTitleElement(), -1); 12203 } 12204 if (element.hasStatusElement()) { 12205 composeEnum(t, "ImplementationGuide", "status", element.getStatusElement(), -1); 12206 } 12207 if (element.hasExperimentalElement()) { 12208 composeBoolean(t, "ImplementationGuide", "experimental", element.getExperimentalElement(), -1); 12209 } 12210 if (element.hasDateElement()) { 12211 composeDateTime(t, "ImplementationGuide", "date", element.getDateElement(), -1); 12212 } 12213 if (element.hasPublisherElement()) { 12214 composeString(t, "ImplementationGuide", "publisher", element.getPublisherElement(), -1); 12215 } 12216 for (int i = 0; i < element.getContact().size(); i++) { 12217 composeContactDetail(t, "ImplementationGuide", "contact", element.getContact().get(i), i); 12218 } 12219 if (element.hasDescriptionElement()) { 12220 composeMarkdown(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 12221 } 12222 for (int i = 0; i < element.getUseContext().size(); i++) { 12223 composeUsageContext(t, "ImplementationGuide", "useContext", element.getUseContext().get(i), i); 12224 } 12225 for (int i = 0; i < element.getJurisdiction().size(); i++) { 12226 composeCodeableConcept(t, "ImplementationGuide", "jurisdiction", element.getJurisdiction().get(i), i); 12227 } 12228 if (element.hasCopyrightElement()) { 12229 composeMarkdown(t, "ImplementationGuide", "copyright", element.getCopyrightElement(), -1); 12230 } 12231 if (element.hasPackageIdElement()) { 12232 composeId(t, "ImplementationGuide", "packageId", element.getPackageIdElement(), -1); 12233 } 12234 if (element.hasLicenseElement()) { 12235 composeEnum(t, "ImplementationGuide", "license", element.getLicenseElement(), -1); 12236 } 12237 for (int i = 0; i < element.getFhirVersion().size(); i++) { 12238 composeEnum(t, "ImplementationGuide", "fhirVersion", element.getFhirVersion().get(i), i); 12239 } 12240 for (int i = 0; i < element.getDependsOn().size(); i++) { 12241 composeImplementationGuideDependsOnComponent(t, "ImplementationGuide", "dependsOn", element.getDependsOn().get(i), i); 12242 } 12243 for (int i = 0; i < element.getGlobal().size(); i++) { 12244 composeImplementationGuideGlobalComponent(t, "ImplementationGuide", "global", element.getGlobal().get(i), i); 12245 } 12246 if (element.hasDefinition()) { 12247 composeImplementationGuideDefinitionComponent(t, "ImplementationGuide", "definition", element.getDefinition(), -1); 12248 } 12249 if (element.hasManifest()) { 12250 composeImplementationGuideManifestComponent(t, "ImplementationGuide", "manifest", element.getManifest(), -1); 12251 } 12252 } 12253 12254 protected void composeImplementationGuideDependsOnComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDependsOnComponent element, int index) { 12255 if (element == null) 12256 return; 12257 Complex t; 12258 if (Utilities.noString(parentType)) 12259 t = parent; 12260 else { 12261 t = parent.predicate("fhir:"+parentType+'.'+name); 12262 } 12263 composeBackboneElement(t, "dependsOn", name, element, index); 12264 if (element.hasUriElement()) { 12265 composeCanonical(t, "ImplementationGuideDependsOnComponent", "uri", element.getUriElement(), -1); 12266 } 12267 if (element.hasPackageIdElement()) { 12268 composeId(t, "ImplementationGuideDependsOnComponent", "packageId", element.getPackageIdElement(), -1); 12269 } 12270 if (element.hasVersionElement()) { 12271 composeString(t, "ImplementationGuideDependsOnComponent", "version", element.getVersionElement(), -1); 12272 } 12273 } 12274 12275 protected void composeImplementationGuideGlobalComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideGlobalComponent element, int index) { 12276 if (element == null) 12277 return; 12278 Complex t; 12279 if (Utilities.noString(parentType)) 12280 t = parent; 12281 else { 12282 t = parent.predicate("fhir:"+parentType+'.'+name); 12283 } 12284 composeBackboneElement(t, "global", name, element, index); 12285 if (element.hasTypeElement()) { 12286 composeCode(t, "ImplementationGuideGlobalComponent", "type", element.getTypeElement(), -1); 12287 } 12288 if (element.hasProfileElement()) { 12289 composeCanonical(t, "ImplementationGuideGlobalComponent", "profile", element.getProfileElement(), -1); 12290 } 12291 } 12292 12293 protected void composeImplementationGuideDefinitionComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionComponent element, int index) { 12294 if (element == null) 12295 return; 12296 Complex t; 12297 if (Utilities.noString(parentType)) 12298 t = parent; 12299 else { 12300 t = parent.predicate("fhir:"+parentType+'.'+name); 12301 } 12302 composeBackboneElement(t, "definition", name, element, index); 12303 for (int i = 0; i < element.getGrouping().size(); i++) { 12304 composeImplementationGuideDefinitionGroupingComponent(t, "ImplementationGuideDefinitionComponent", "grouping", element.getGrouping().get(i), i); 12305 } 12306 for (int i = 0; i < element.getResource().size(); i++) { 12307 composeImplementationGuideDefinitionResourceComponent(t, "ImplementationGuideDefinitionComponent", "resource", element.getResource().get(i), i); 12308 } 12309 if (element.hasPage()) { 12310 composeImplementationGuideDefinitionPageComponent(t, "ImplementationGuideDefinitionComponent", "page", element.getPage(), -1); 12311 } 12312 for (int i = 0; i < element.getParameter().size(); i++) { 12313 composeImplementationGuideDefinitionParameterComponent(t, "ImplementationGuideDefinitionComponent", "parameter", element.getParameter().get(i), i); 12314 } 12315 for (int i = 0; i < element.getTemplate().size(); i++) { 12316 composeImplementationGuideDefinitionTemplateComponent(t, "ImplementationGuideDefinitionComponent", "template", element.getTemplate().get(i), i); 12317 } 12318 } 12319 12320 protected void composeImplementationGuideDefinitionGroupingComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionGroupingComponent element, int index) { 12321 if (element == null) 12322 return; 12323 Complex t; 12324 if (Utilities.noString(parentType)) 12325 t = parent; 12326 else { 12327 t = parent.predicate("fhir:"+parentType+'.'+name); 12328 } 12329 composeBackboneElement(t, "grouping", name, element, index); 12330 if (element.hasNameElement()) { 12331 composeString(t, "ImplementationGuideDefinitionGroupingComponent", "name", element.getNameElement(), -1); 12332 } 12333 if (element.hasDescriptionElement()) { 12334 composeString(t, "ImplementationGuideDefinitionGroupingComponent", "description", element.getDescriptionElement(), -1); 12335 } 12336 } 12337 12338 protected void composeImplementationGuideDefinitionResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionResourceComponent element, int index) { 12339 if (element == null) 12340 return; 12341 Complex t; 12342 if (Utilities.noString(parentType)) 12343 t = parent; 12344 else { 12345 t = parent.predicate("fhir:"+parentType+'.'+name); 12346 } 12347 composeBackboneElement(t, "resource", name, element, index); 12348 if (element.hasReference()) { 12349 composeReference(t, "ImplementationGuideDefinitionResourceComponent", "reference", element.getReference(), -1); 12350 } 12351 for (int i = 0; i < element.getFhirVersion().size(); i++) { 12352 composeEnum(t, "ImplementationGuideDefinitionResourceComponent", "fhirVersion", element.getFhirVersion().get(i), i); 12353 } 12354 if (element.hasNameElement()) { 12355 composeString(t, "ImplementationGuideDefinitionResourceComponent", "name", element.getNameElement(), -1); 12356 } 12357 if (element.hasDescriptionElement()) { 12358 composeString(t, "ImplementationGuideDefinitionResourceComponent", "description", element.getDescriptionElement(), -1); 12359 } 12360 if (element.hasExample()) { 12361 composeType(t, "ImplementationGuideDefinitionResourceComponent", "example", element.getExample(), -1); 12362 } 12363 if (element.hasGroupingIdElement()) { 12364 composeId(t, "ImplementationGuideDefinitionResourceComponent", "groupingId", element.getGroupingIdElement(), -1); 12365 } 12366 } 12367 12368 protected void composeImplementationGuideDefinitionPageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionPageComponent element, int index) { 12369 if (element == null) 12370 return; 12371 Complex t; 12372 if (Utilities.noString(parentType)) 12373 t = parent; 12374 else { 12375 t = parent.predicate("fhir:"+parentType+'.'+name); 12376 } 12377 composeBackboneElement(t, "page", name, element, index); 12378 if (element.hasName()) { 12379 composeType(t, "ImplementationGuideDefinitionPageComponent", "name", element.getName(), -1); 12380 } 12381 if (element.hasTitleElement()) { 12382 composeString(t, "ImplementationGuideDefinitionPageComponent", "title", element.getTitleElement(), -1); 12383 } 12384 if (element.hasGenerationElement()) { 12385 composeEnum(t, "ImplementationGuideDefinitionPageComponent", "generation", element.getGenerationElement(), -1); 12386 } 12387 for (int i = 0; i < element.getPage().size(); i++) { 12388 composeImplementationGuideDefinitionPageComponent(t, "ImplementationGuideDefinitionPageComponent", "page", element.getPage().get(i), i); 12389 } 12390 } 12391 12392 protected void composeImplementationGuideDefinitionParameterComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionParameterComponent element, int index) { 12393 if (element == null) 12394 return; 12395 Complex t; 12396 if (Utilities.noString(parentType)) 12397 t = parent; 12398 else { 12399 t = parent.predicate("fhir:"+parentType+'.'+name); 12400 } 12401 composeBackboneElement(t, "parameter", name, element, index); 12402 if (element.hasCodeElement()) { 12403 composeString(t, "ImplementationGuideDefinitionParameterComponent", "code", element.getCodeElement(), -1); 12404 } 12405 if (element.hasValueElement()) { 12406 composeString(t, "ImplementationGuideDefinitionParameterComponent", "value", element.getValueElement(), -1); 12407 } 12408 } 12409 12410 protected void composeImplementationGuideDefinitionTemplateComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDefinitionTemplateComponent element, int index) { 12411 if (element == null) 12412 return; 12413 Complex t; 12414 if (Utilities.noString(parentType)) 12415 t = parent; 12416 else { 12417 t = parent.predicate("fhir:"+parentType+'.'+name); 12418 } 12419 composeBackboneElement(t, "template", name, element, index); 12420 if (element.hasCodeElement()) { 12421 composeCode(t, "ImplementationGuideDefinitionTemplateComponent", "code", element.getCodeElement(), -1); 12422 } 12423 if (element.hasSourceElement()) { 12424 composeString(t, "ImplementationGuideDefinitionTemplateComponent", "source", element.getSourceElement(), -1); 12425 } 12426 if (element.hasScopeElement()) { 12427 composeString(t, "ImplementationGuideDefinitionTemplateComponent", "scope", element.getScopeElement(), -1); 12428 } 12429 } 12430 12431 protected void composeImplementationGuideManifestComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideManifestComponent element, int index) { 12432 if (element == null) 12433 return; 12434 Complex t; 12435 if (Utilities.noString(parentType)) 12436 t = parent; 12437 else { 12438 t = parent.predicate("fhir:"+parentType+'.'+name); 12439 } 12440 composeBackboneElement(t, "manifest", name, element, index); 12441 if (element.hasRenderingElement()) { 12442 composeUrl(t, "ImplementationGuideManifestComponent", "rendering", element.getRenderingElement(), -1); 12443 } 12444 for (int i = 0; i < element.getResource().size(); i++) { 12445 composeImplementationGuideManifestResourceComponent(t, "ImplementationGuideManifestComponent", "resource", element.getResource().get(i), i); 12446 } 12447 for (int i = 0; i < element.getPage().size(); i++) { 12448 composeImplementationGuideManifestPageComponent(t, "ImplementationGuideManifestComponent", "page", element.getPage().get(i), i); 12449 } 12450 for (int i = 0; i < element.getImage().size(); i++) { 12451 composeString(t, "ImplementationGuideManifestComponent", "image", element.getImage().get(i), i); 12452 } 12453 for (int i = 0; i < element.getOther().size(); i++) { 12454 composeString(t, "ImplementationGuideManifestComponent", "other", element.getOther().get(i), i); 12455 } 12456 } 12457 12458 protected void composeImplementationGuideManifestResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ManifestResourceComponent element, int index) { 12459 if (element == null) 12460 return; 12461 Complex t; 12462 if (Utilities.noString(parentType)) 12463 t = parent; 12464 else { 12465 t = parent.predicate("fhir:"+parentType+'.'+name); 12466 } 12467 composeBackboneElement(t, "resource", name, element, index); 12468 if (element.hasReference()) { 12469 composeReference(t, "ManifestResourceComponent", "reference", element.getReference(), -1); 12470 } 12471 if (element.hasExample()) { 12472 composeType(t, "ManifestResourceComponent", "example", element.getExample(), -1); 12473 } 12474 if (element.hasRelativePathElement()) { 12475 composeUrl(t, "ManifestResourceComponent", "relativePath", element.getRelativePathElement(), -1); 12476 } 12477 } 12478 12479 protected void composeImplementationGuideManifestPageComponent(Complex parent, String parentType, String name, ImplementationGuide.ManifestPageComponent element, int index) { 12480 if (element == null) 12481 return; 12482 Complex t; 12483 if (Utilities.noString(parentType)) 12484 t = parent; 12485 else { 12486 t = parent.predicate("fhir:"+parentType+'.'+name); 12487 } 12488 composeBackboneElement(t, "page", name, element, index); 12489 if (element.hasNameElement()) { 12490 composeString(t, "ManifestPageComponent", "name", element.getNameElement(), -1); 12491 } 12492 if (element.hasTitleElement()) { 12493 composeString(t, "ManifestPageComponent", "title", element.getTitleElement(), -1); 12494 } 12495 for (int i = 0; i < element.getAnchor().size(); i++) { 12496 composeString(t, "ManifestPageComponent", "anchor", element.getAnchor().get(i), i); 12497 } 12498 } 12499 12500 protected void composeIngredient(Complex parent, String parentType, String name, Ingredient 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 composeDomainResource(t, "Ingredient", name, element, index); 12510 if (element.hasIdentifier()) { 12511 composeIdentifier(t, "Ingredient", "identifier", element.getIdentifier(), -1); 12512 } 12513 if (element.hasRole()) { 12514 composeCodeableConcept(t, "Ingredient", "role", element.getRole(), -1); 12515 } 12516 if (element.hasAllergenicIndicatorElement()) { 12517 composeBoolean(t, "Ingredient", "allergenicIndicator", element.getAllergenicIndicatorElement(), -1); 12518 } 12519 for (int i = 0; i < element.getManufacturer().size(); i++) { 12520 composeReference(t, "Ingredient", "manufacturer", element.getManufacturer().get(i), i); 12521 } 12522 for (int i = 0; i < element.getSpecifiedSubstance().size(); i++) { 12523 composeIngredientSpecifiedSubstanceComponent(t, "Ingredient", "specifiedSubstance", element.getSpecifiedSubstance().get(i), i); 12524 } 12525 if (element.hasSubstance()) { 12526 composeIngredientSubstanceComponent(t, "Ingredient", "substance", element.getSubstance(), -1); 12527 } 12528 } 12529 12530 protected void composeIngredientSpecifiedSubstanceComponent(Complex parent, String parentType, String name, Ingredient.IngredientSpecifiedSubstanceComponent 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, "specifiedSubstance", name, element, index); 12540 if (element.hasCode()) { 12541 composeType(t, "IngredientSpecifiedSubstanceComponent", "code", element.getCode(), -1); 12542 } 12543 if (element.hasGroup()) { 12544 composeCodeableConcept(t, "IngredientSpecifiedSubstanceComponent", "group", element.getGroup(), -1); 12545 } 12546 if (element.hasConfidentiality()) { 12547 composeCodeableConcept(t, "IngredientSpecifiedSubstanceComponent", "confidentiality", element.getConfidentiality(), -1); 12548 } 12549 for (int i = 0; i < element.getStrength().size(); i++) { 12550 composeIngredientSpecifiedSubstanceStrengthComponent(t, "IngredientSpecifiedSubstanceComponent", "strength", element.getStrength().get(i), i); 12551 } 12552 } 12553 12554 protected void composeIngredientSpecifiedSubstanceStrengthComponent(Complex parent, String parentType, String name, Ingredient.IngredientSpecifiedSubstanceStrengthComponent 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 composeBackboneElement(t, "strength", name, element, index); 12564 if (element.hasPresentation()) { 12565 composeRatio(t, "IngredientSpecifiedSubstanceStrengthComponent", "presentation", element.getPresentation(), -1); 12566 } 12567 if (element.hasPresentationHighLimit()) { 12568 composeRatio(t, "IngredientSpecifiedSubstanceStrengthComponent", "presentationHighLimit", element.getPresentationHighLimit(), -1); 12569 } 12570 if (element.hasConcentration()) { 12571 composeRatio(t, "IngredientSpecifiedSubstanceStrengthComponent", "concentration", element.getConcentration(), -1); 12572 } 12573 if (element.hasConcentrationHighLimit()) { 12574 composeRatio(t, "IngredientSpecifiedSubstanceStrengthComponent", "concentrationHighLimit", element.getConcentrationHighLimit(), -1); 12575 } 12576 if (element.hasMeasurementPointElement()) { 12577 composeString(t, "IngredientSpecifiedSubstanceStrengthComponent", "measurementPoint", element.getMeasurementPointElement(), -1); 12578 } 12579 for (int i = 0; i < element.getCountry().size(); i++) { 12580 composeCodeableConcept(t, "IngredientSpecifiedSubstanceStrengthComponent", "country", element.getCountry().get(i), i); 12581 } 12582 for (int i = 0; i < element.getReferenceStrength().size(); i++) { 12583 composeIngredientSpecifiedSubstanceStrengthReferenceStrengthComponent(t, "IngredientSpecifiedSubstanceStrengthComponent", "referenceStrength", element.getReferenceStrength().get(i), i); 12584 } 12585 } 12586 12587 protected void composeIngredientSpecifiedSubstanceStrengthReferenceStrengthComponent(Complex parent, String parentType, String name, Ingredient.IngredientSpecifiedSubstanceStrengthReferenceStrengthComponent element, int index) { 12588 if (element == null) 12589 return; 12590 Complex t; 12591 if (Utilities.noString(parentType)) 12592 t = parent; 12593 else { 12594 t = parent.predicate("fhir:"+parentType+'.'+name); 12595 } 12596 composeBackboneElement(t, "referenceStrength", name, element, index); 12597 if (element.hasSubstance()) { 12598 composeType(t, "IngredientSpecifiedSubstanceStrengthReferenceStrengthComponent", "substance", element.getSubstance(), -1); 12599 } 12600 if (element.hasStrength()) { 12601 composeRatio(t, "IngredientSpecifiedSubstanceStrengthReferenceStrengthComponent", "strength", element.getStrength(), -1); 12602 } 12603 if (element.hasStrengthHighLimit()) { 12604 composeRatio(t, "IngredientSpecifiedSubstanceStrengthReferenceStrengthComponent", "strengthHighLimit", element.getStrengthHighLimit(), -1); 12605 } 12606 if (element.hasMeasurementPointElement()) { 12607 composeString(t, "IngredientSpecifiedSubstanceStrengthReferenceStrengthComponent", "measurementPoint", element.getMeasurementPointElement(), -1); 12608 } 12609 for (int i = 0; i < element.getCountry().size(); i++) { 12610 composeCodeableConcept(t, "IngredientSpecifiedSubstanceStrengthReferenceStrengthComponent", "country", element.getCountry().get(i), i); 12611 } 12612 } 12613 12614 protected void composeIngredientSubstanceComponent(Complex parent, String parentType, String name, Ingredient.IngredientSubstanceComponent element, int index) { 12615 if (element == null) 12616 return; 12617 Complex t; 12618 if (Utilities.noString(parentType)) 12619 t = parent; 12620 else { 12621 t = parent.predicate("fhir:"+parentType+'.'+name); 12622 } 12623 composeBackboneElement(t, "substance", name, element, index); 12624 if (element.hasCode()) { 12625 composeType(t, "IngredientSubstanceComponent", "code", element.getCode(), -1); 12626 } 12627 for (int i = 0; i < element.getStrength().size(); i++) { 12628 composeIngredientSpecifiedSubstanceStrengthComponent(t, "IngredientSubstanceComponent", "strength", element.getStrength().get(i), i); 12629 } 12630 } 12631 12632 protected void composeInsurancePlan(Complex parent, String parentType, String name, InsurancePlan element, int index) { 12633 if (element == null) 12634 return; 12635 Complex t; 12636 if (Utilities.noString(parentType)) 12637 t = parent; 12638 else { 12639 t = parent.predicate("fhir:"+parentType+'.'+name); 12640 } 12641 composeDomainResource(t, "InsurancePlan", name, element, index); 12642 for (int i = 0; i < element.getIdentifier().size(); i++) { 12643 composeIdentifier(t, "InsurancePlan", "identifier", element.getIdentifier().get(i), i); 12644 } 12645 if (element.hasStatusElement()) { 12646 composeEnum(t, "InsurancePlan", "status", element.getStatusElement(), -1); 12647 } 12648 for (int i = 0; i < element.getType().size(); i++) { 12649 composeCodeableConcept(t, "InsurancePlan", "type", element.getType().get(i), i); 12650 } 12651 if (element.hasNameElement()) { 12652 composeString(t, "InsurancePlan", "name", element.getNameElement(), -1); 12653 } 12654 for (int i = 0; i < element.getAlias().size(); i++) { 12655 composeString(t, "InsurancePlan", "alias", element.getAlias().get(i), i); 12656 } 12657 if (element.hasPeriod()) { 12658 composePeriod(t, "InsurancePlan", "period", element.getPeriod(), -1); 12659 } 12660 if (element.hasOwnedBy()) { 12661 composeReference(t, "InsurancePlan", "ownedBy", element.getOwnedBy(), -1); 12662 } 12663 if (element.hasAdministeredBy()) { 12664 composeReference(t, "InsurancePlan", "administeredBy", element.getAdministeredBy(), -1); 12665 } 12666 for (int i = 0; i < element.getCoverageArea().size(); i++) { 12667 composeReference(t, "InsurancePlan", "coverageArea", element.getCoverageArea().get(i), i); 12668 } 12669 for (int i = 0; i < element.getContact().size(); i++) { 12670 composeInsurancePlanContactComponent(t, "InsurancePlan", "contact", element.getContact().get(i), i); 12671 } 12672 for (int i = 0; i < element.getEndpoint().size(); i++) { 12673 composeReference(t, "InsurancePlan", "endpoint", element.getEndpoint().get(i), i); 12674 } 12675 for (int i = 0; i < element.getNetwork().size(); i++) { 12676 composeReference(t, "InsurancePlan", "network", element.getNetwork().get(i), i); 12677 } 12678 for (int i = 0; i < element.getCoverage().size(); i++) { 12679 composeInsurancePlanCoverageComponent(t, "InsurancePlan", "coverage", element.getCoverage().get(i), i); 12680 } 12681 for (int i = 0; i < element.getPlan().size(); i++) { 12682 composeInsurancePlanPlanComponent(t, "InsurancePlan", "plan", element.getPlan().get(i), i); 12683 } 12684 } 12685 12686 protected void composeInsurancePlanContactComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanContactComponent 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 if (element.hasPurpose()) { 12697 composeCodeableConcept(t, "InsurancePlanContactComponent", "purpose", element.getPurpose(), -1); 12698 } 12699 if (element.hasName()) { 12700 composeHumanName(t, "InsurancePlanContactComponent", "name", element.getName(), -1); 12701 } 12702 for (int i = 0; i < element.getTelecom().size(); i++) { 12703 composeContactPoint(t, "InsurancePlanContactComponent", "telecom", element.getTelecom().get(i), i); 12704 } 12705 if (element.hasAddress()) { 12706 composeAddress(t, "InsurancePlanContactComponent", "address", element.getAddress(), -1); 12707 } 12708 } 12709 12710 protected void composeInsurancePlanCoverageComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanCoverageComponent element, int index) { 12711 if (element == null) 12712 return; 12713 Complex t; 12714 if (Utilities.noString(parentType)) 12715 t = parent; 12716 else { 12717 t = parent.predicate("fhir:"+parentType+'.'+name); 12718 } 12719 composeBackboneElement(t, "coverage", name, element, index); 12720 if (element.hasType()) { 12721 composeCodeableConcept(t, "InsurancePlanCoverageComponent", "type", element.getType(), -1); 12722 } 12723 for (int i = 0; i < element.getNetwork().size(); i++) { 12724 composeReference(t, "InsurancePlanCoverageComponent", "network", element.getNetwork().get(i), i); 12725 } 12726 for (int i = 0; i < element.getBenefit().size(); i++) { 12727 composeInsurancePlanCoverageBenefitComponent(t, "InsurancePlanCoverageComponent", "benefit", element.getBenefit().get(i), i); 12728 } 12729 } 12730 12731 protected void composeInsurancePlanCoverageBenefitComponent(Complex parent, String parentType, String name, InsurancePlan.CoverageBenefitComponent element, int index) { 12732 if (element == null) 12733 return; 12734 Complex t; 12735 if (Utilities.noString(parentType)) 12736 t = parent; 12737 else { 12738 t = parent.predicate("fhir:"+parentType+'.'+name); 12739 } 12740 composeBackboneElement(t, "benefit", name, element, index); 12741 if (element.hasType()) { 12742 composeCodeableConcept(t, "CoverageBenefitComponent", "type", element.getType(), -1); 12743 } 12744 if (element.hasRequirementElement()) { 12745 composeString(t, "CoverageBenefitComponent", "requirement", element.getRequirementElement(), -1); 12746 } 12747 for (int i = 0; i < element.getLimit().size(); i++) { 12748 composeInsurancePlanCoverageBenefitLimitComponent(t, "CoverageBenefitComponent", "limit", element.getLimit().get(i), i); 12749 } 12750 } 12751 12752 protected void composeInsurancePlanCoverageBenefitLimitComponent(Complex parent, String parentType, String name, InsurancePlan.CoverageBenefitLimitComponent element, int index) { 12753 if (element == null) 12754 return; 12755 Complex t; 12756 if (Utilities.noString(parentType)) 12757 t = parent; 12758 else { 12759 t = parent.predicate("fhir:"+parentType+'.'+name); 12760 } 12761 composeBackboneElement(t, "limit", name, element, index); 12762 if (element.hasValue()) { 12763 composeQuantity(t, "CoverageBenefitLimitComponent", "value", element.getValue(), -1); 12764 } 12765 if (element.hasCode()) { 12766 composeCodeableConcept(t, "CoverageBenefitLimitComponent", "code", element.getCode(), -1); 12767 } 12768 } 12769 12770 protected void composeInsurancePlanPlanComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanComponent element, int index) { 12771 if (element == null) 12772 return; 12773 Complex t; 12774 if (Utilities.noString(parentType)) 12775 t = parent; 12776 else { 12777 t = parent.predicate("fhir:"+parentType+'.'+name); 12778 } 12779 composeBackboneElement(t, "plan", name, element, index); 12780 for (int i = 0; i < element.getIdentifier().size(); i++) { 12781 composeIdentifier(t, "InsurancePlanPlanComponent", "identifier", element.getIdentifier().get(i), i); 12782 } 12783 if (element.hasType()) { 12784 composeCodeableConcept(t, "InsurancePlanPlanComponent", "type", element.getType(), -1); 12785 } 12786 for (int i = 0; i < element.getCoverageArea().size(); i++) { 12787 composeReference(t, "InsurancePlanPlanComponent", "coverageArea", element.getCoverageArea().get(i), i); 12788 } 12789 for (int i = 0; i < element.getNetwork().size(); i++) { 12790 composeReference(t, "InsurancePlanPlanComponent", "network", element.getNetwork().get(i), i); 12791 } 12792 for (int i = 0; i < element.getGeneralCost().size(); i++) { 12793 composeInsurancePlanPlanGeneralCostComponent(t, "InsurancePlanPlanComponent", "generalCost", element.getGeneralCost().get(i), i); 12794 } 12795 for (int i = 0; i < element.getSpecificCost().size(); i++) { 12796 composeInsurancePlanPlanSpecificCostComponent(t, "InsurancePlanPlanComponent", "specificCost", element.getSpecificCost().get(i), i); 12797 } 12798 } 12799 12800 protected void composeInsurancePlanPlanGeneralCostComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanGeneralCostComponent element, int index) { 12801 if (element == null) 12802 return; 12803 Complex t; 12804 if (Utilities.noString(parentType)) 12805 t = parent; 12806 else { 12807 t = parent.predicate("fhir:"+parentType+'.'+name); 12808 } 12809 composeBackboneElement(t, "generalCost", name, element, index); 12810 if (element.hasType()) { 12811 composeCodeableConcept(t, "InsurancePlanPlanGeneralCostComponent", "type", element.getType(), -1); 12812 } 12813 if (element.hasGroupSizeElement()) { 12814 composePositiveInt(t, "InsurancePlanPlanGeneralCostComponent", "groupSize", element.getGroupSizeElement(), -1); 12815 } 12816 if (element.hasCost()) { 12817 composeMoney(t, "InsurancePlanPlanGeneralCostComponent", "cost", element.getCost(), -1); 12818 } 12819 if (element.hasCommentElement()) { 12820 composeString(t, "InsurancePlanPlanGeneralCostComponent", "comment", element.getCommentElement(), -1); 12821 } 12822 } 12823 12824 protected void composeInsurancePlanPlanSpecificCostComponent(Complex parent, String parentType, String name, InsurancePlan.InsurancePlanPlanSpecificCostComponent element, int index) { 12825 if (element == null) 12826 return; 12827 Complex t; 12828 if (Utilities.noString(parentType)) 12829 t = parent; 12830 else { 12831 t = parent.predicate("fhir:"+parentType+'.'+name); 12832 } 12833 composeBackboneElement(t, "specificCost", name, element, index); 12834 if (element.hasCategory()) { 12835 composeCodeableConcept(t, "InsurancePlanPlanSpecificCostComponent", "category", element.getCategory(), -1); 12836 } 12837 for (int i = 0; i < element.getBenefit().size(); i++) { 12838 composeInsurancePlanPlanBenefitComponent(t, "InsurancePlanPlanSpecificCostComponent", "benefit", element.getBenefit().get(i), i); 12839 } 12840 } 12841 12842 protected void composeInsurancePlanPlanBenefitComponent(Complex parent, String parentType, String name, InsurancePlan.PlanBenefitComponent element, int index) { 12843 if (element == null) 12844 return; 12845 Complex t; 12846 if (Utilities.noString(parentType)) 12847 t = parent; 12848 else { 12849 t = parent.predicate("fhir:"+parentType+'.'+name); 12850 } 12851 composeBackboneElement(t, "benefit", name, element, index); 12852 if (element.hasType()) { 12853 composeCodeableConcept(t, "PlanBenefitComponent", "type", element.getType(), -1); 12854 } 12855 for (int i = 0; i < element.getCost().size(); i++) { 12856 composeInsurancePlanPlanBenefitCostComponent(t, "PlanBenefitComponent", "cost", element.getCost().get(i), i); 12857 } 12858 } 12859 12860 protected void composeInsurancePlanPlanBenefitCostComponent(Complex parent, String parentType, String name, InsurancePlan.PlanBenefitCostComponent element, int index) { 12861 if (element == null) 12862 return; 12863 Complex t; 12864 if (Utilities.noString(parentType)) 12865 t = parent; 12866 else { 12867 t = parent.predicate("fhir:"+parentType+'.'+name); 12868 } 12869 composeBackboneElement(t, "cost", name, element, index); 12870 if (element.hasType()) { 12871 composeCodeableConcept(t, "PlanBenefitCostComponent", "type", element.getType(), -1); 12872 } 12873 if (element.hasApplicability()) { 12874 composeCodeableConcept(t, "PlanBenefitCostComponent", "applicability", element.getApplicability(), -1); 12875 } 12876 for (int i = 0; i < element.getQualifiers().size(); i++) { 12877 composeCodeableConcept(t, "PlanBenefitCostComponent", "qualifiers", element.getQualifiers().get(i), i); 12878 } 12879 if (element.hasValue()) { 12880 composeQuantity(t, "PlanBenefitCostComponent", "value", element.getValue(), -1); 12881 } 12882 } 12883 12884 protected void composeInvoice(Complex parent, String parentType, String name, Invoice element, int index) { 12885 if (element == null) 12886 return; 12887 Complex t; 12888 if (Utilities.noString(parentType)) 12889 t = parent; 12890 else { 12891 t = parent.predicate("fhir:"+parentType+'.'+name); 12892 } 12893 composeDomainResource(t, "Invoice", name, element, index); 12894 for (int i = 0; i < element.getIdentifier().size(); i++) { 12895 composeIdentifier(t, "Invoice", "identifier", element.getIdentifier().get(i), i); 12896 } 12897 if (element.hasStatusElement()) { 12898 composeEnum(t, "Invoice", "status", element.getStatusElement(), -1); 12899 } 12900 if (element.hasCancelledReasonElement()) { 12901 composeString(t, "Invoice", "cancelledReason", element.getCancelledReasonElement(), -1); 12902 } 12903 if (element.hasType()) { 12904 composeCodeableConcept(t, "Invoice", "type", element.getType(), -1); 12905 } 12906 if (element.hasSubject()) { 12907 composeReference(t, "Invoice", "subject", element.getSubject(), -1); 12908 } 12909 if (element.hasRecipient()) { 12910 composeReference(t, "Invoice", "recipient", element.getRecipient(), -1); 12911 } 12912 if (element.hasDateElement()) { 12913 composeDateTime(t, "Invoice", "date", element.getDateElement(), -1); 12914 } 12915 for (int i = 0; i < element.getParticipant().size(); i++) { 12916 composeInvoiceParticipantComponent(t, "Invoice", "participant", element.getParticipant().get(i), i); 12917 } 12918 if (element.hasIssuer()) { 12919 composeReference(t, "Invoice", "issuer", element.getIssuer(), -1); 12920 } 12921 if (element.hasAccount()) { 12922 composeReference(t, "Invoice", "account", element.getAccount(), -1); 12923 } 12924 for (int i = 0; i < element.getLineItem().size(); i++) { 12925 composeInvoiceLineItemComponent(t, "Invoice", "lineItem", element.getLineItem().get(i), i); 12926 } 12927 for (int i = 0; i < element.getTotalPriceComponent().size(); i++) { 12928 composeInvoiceLineItemPriceComponentComponent(t, "Invoice", "totalPriceComponent", element.getTotalPriceComponent().get(i), i); 12929 } 12930 if (element.hasTotalNet()) { 12931 composeMoney(t, "Invoice", "totalNet", element.getTotalNet(), -1); 12932 } 12933 if (element.hasTotalGross()) { 12934 composeMoney(t, "Invoice", "totalGross", element.getTotalGross(), -1); 12935 } 12936 if (element.hasPaymentTermsElement()) { 12937 composeMarkdown(t, "Invoice", "paymentTerms", element.getPaymentTermsElement(), -1); 12938 } 12939 for (int i = 0; i < element.getNote().size(); i++) { 12940 composeAnnotation(t, "Invoice", "note", element.getNote().get(i), i); 12941 } 12942 } 12943 12944 protected void composeInvoiceParticipantComponent(Complex parent, String parentType, String name, Invoice.InvoiceParticipantComponent element, int index) { 12945 if (element == null) 12946 return; 12947 Complex t; 12948 if (Utilities.noString(parentType)) 12949 t = parent; 12950 else { 12951 t = parent.predicate("fhir:"+parentType+'.'+name); 12952 } 12953 composeBackboneElement(t, "participant", name, element, index); 12954 if (element.hasRole()) { 12955 composeCodeableConcept(t, "InvoiceParticipantComponent", "role", element.getRole(), -1); 12956 } 12957 if (element.hasActor()) { 12958 composeReference(t, "InvoiceParticipantComponent", "actor", element.getActor(), -1); 12959 } 12960 } 12961 12962 protected void composeInvoiceLineItemComponent(Complex parent, String parentType, String name, Invoice.InvoiceLineItemComponent element, int index) { 12963 if (element == null) 12964 return; 12965 Complex t; 12966 if (Utilities.noString(parentType)) 12967 t = parent; 12968 else { 12969 t = parent.predicate("fhir:"+parentType+'.'+name); 12970 } 12971 composeBackboneElement(t, "lineItem", name, element, index); 12972 if (element.hasSequenceElement()) { 12973 composePositiveInt(t, "InvoiceLineItemComponent", "sequence", element.getSequenceElement(), -1); 12974 } 12975 if (element.hasChargeItem()) { 12976 composeType(t, "InvoiceLineItemComponent", "chargeItem", element.getChargeItem(), -1); 12977 } 12978 for (int i = 0; i < element.getPriceComponent().size(); i++) { 12979 composeInvoiceLineItemPriceComponentComponent(t, "InvoiceLineItemComponent", "priceComponent", element.getPriceComponent().get(i), i); 12980 } 12981 } 12982 12983 protected void composeInvoiceLineItemPriceComponentComponent(Complex parent, String parentType, String name, Invoice.InvoiceLineItemPriceComponentComponent element, int index) { 12984 if (element == null) 12985 return; 12986 Complex t; 12987 if (Utilities.noString(parentType)) 12988 t = parent; 12989 else { 12990 t = parent.predicate("fhir:"+parentType+'.'+name); 12991 } 12992 composeBackboneElement(t, "priceComponent", name, element, index); 12993 if (element.hasTypeElement()) { 12994 composeEnum(t, "InvoiceLineItemPriceComponentComponent", "type", element.getTypeElement(), -1); 12995 } 12996 if (element.hasCode()) { 12997 composeCodeableConcept(t, "InvoiceLineItemPriceComponentComponent", "code", element.getCode(), -1); 12998 } 12999 if (element.hasFactorElement()) { 13000 composeDecimal(t, "InvoiceLineItemPriceComponentComponent", "factor", element.getFactorElement(), -1); 13001 } 13002 if (element.hasAmount()) { 13003 composeMoney(t, "InvoiceLineItemPriceComponentComponent", "amount", element.getAmount(), -1); 13004 } 13005 } 13006 13007 protected void composeLibrary(Complex parent, String parentType, String name, Library element, int index) { 13008 if (element == null) 13009 return; 13010 Complex t; 13011 if (Utilities.noString(parentType)) 13012 t = parent; 13013 else { 13014 t = parent.predicate("fhir:"+parentType+'.'+name); 13015 } 13016 composeMetadataResource(t, "Library", name, element, index); 13017 if (element.hasUrlElement()) { 13018 composeUri(t, "Library", "url", element.getUrlElement(), -1); 13019 } 13020 for (int i = 0; i < element.getIdentifier().size(); i++) { 13021 composeIdentifier(t, "Library", "identifier", element.getIdentifier().get(i), i); 13022 } 13023 if (element.hasVersionElement()) { 13024 composeString(t, "Library", "version", element.getVersionElement(), -1); 13025 } 13026 if (element.hasNameElement()) { 13027 composeString(t, "Library", "name", element.getNameElement(), -1); 13028 } 13029 if (element.hasTitleElement()) { 13030 composeString(t, "Library", "title", element.getTitleElement(), -1); 13031 } 13032 if (element.hasSubtitleElement()) { 13033 composeString(t, "Library", "subtitle", element.getSubtitleElement(), -1); 13034 } 13035 if (element.hasStatusElement()) { 13036 composeEnum(t, "Library", "status", element.getStatusElement(), -1); 13037 } 13038 if (element.hasExperimentalElement()) { 13039 composeBoolean(t, "Library", "experimental", element.getExperimentalElement(), -1); 13040 } 13041 if (element.hasType()) { 13042 composeCodeableConcept(t, "Library", "type", element.getType(), -1); 13043 } 13044 if (element.hasSubject()) { 13045 composeType(t, "Library", "subject", element.getSubject(), -1); 13046 } 13047 if (element.hasDateElement()) { 13048 composeDateTime(t, "Library", "date", element.getDateElement(), -1); 13049 } 13050 if (element.hasPublisherElement()) { 13051 composeString(t, "Library", "publisher", element.getPublisherElement(), -1); 13052 } 13053 for (int i = 0; i < element.getContact().size(); i++) { 13054 composeContactDetail(t, "Library", "contact", element.getContact().get(i), i); 13055 } 13056 if (element.hasDescriptionElement()) { 13057 composeMarkdown(t, "Library", "description", element.getDescriptionElement(), -1); 13058 } 13059 for (int i = 0; i < element.getUseContext().size(); i++) { 13060 composeUsageContext(t, "Library", "useContext", element.getUseContext().get(i), i); 13061 } 13062 for (int i = 0; i < element.getJurisdiction().size(); i++) { 13063 composeCodeableConcept(t, "Library", "jurisdiction", element.getJurisdiction().get(i), i); 13064 } 13065 if (element.hasPurposeElement()) { 13066 composeMarkdown(t, "Library", "purpose", element.getPurposeElement(), -1); 13067 } 13068 if (element.hasUsageElement()) { 13069 composeString(t, "Library", "usage", element.getUsageElement(), -1); 13070 } 13071 if (element.hasCopyrightElement()) { 13072 composeMarkdown(t, "Library", "copyright", element.getCopyrightElement(), -1); 13073 } 13074 if (element.hasApprovalDateElement()) { 13075 composeDate(t, "Library", "approvalDate", element.getApprovalDateElement(), -1); 13076 } 13077 if (element.hasLastReviewDateElement()) { 13078 composeDate(t, "Library", "lastReviewDate", element.getLastReviewDateElement(), -1); 13079 } 13080 if (element.hasEffectivePeriod()) { 13081 composePeriod(t, "Library", "effectivePeriod", element.getEffectivePeriod(), -1); 13082 } 13083 for (int i = 0; i < element.getTopic().size(); i++) { 13084 composeCodeableConcept(t, "Library", "topic", element.getTopic().get(i), i); 13085 } 13086 for (int i = 0; i < element.getAuthor().size(); i++) { 13087 composeContactDetail(t, "Library", "author", element.getAuthor().get(i), i); 13088 } 13089 for (int i = 0; i < element.getEditor().size(); i++) { 13090 composeContactDetail(t, "Library", "editor", element.getEditor().get(i), i); 13091 } 13092 for (int i = 0; i < element.getReviewer().size(); i++) { 13093 composeContactDetail(t, "Library", "reviewer", element.getReviewer().get(i), i); 13094 } 13095 for (int i = 0; i < element.getEndorser().size(); i++) { 13096 composeContactDetail(t, "Library", "endorser", element.getEndorser().get(i), i); 13097 } 13098 for (int i = 0; i < element.getRelatedArtifact().size(); i++) { 13099 composeRelatedArtifact(t, "Library", "relatedArtifact", element.getRelatedArtifact().get(i), i); 13100 } 13101 for (int i = 0; i < element.getParameter().size(); i++) { 13102 composeParameterDefinition(t, "Library", "parameter", element.getParameter().get(i), i); 13103 } 13104 for (int i = 0; i < element.getDataRequirement().size(); i++) { 13105 composeDataRequirement(t, "Library", "dataRequirement", element.getDataRequirement().get(i), i); 13106 } 13107 for (int i = 0; i < element.getContent().size(); i++) { 13108 composeAttachment(t, "Library", "content", element.getContent().get(i), i); 13109 } 13110 } 13111 13112 protected void composeLinkage(Complex parent, String parentType, String name, Linkage element, int index) { 13113 if (element == null) 13114 return; 13115 Complex t; 13116 if (Utilities.noString(parentType)) 13117 t = parent; 13118 else { 13119 t = parent.predicate("fhir:"+parentType+'.'+name); 13120 } 13121 composeDomainResource(t, "Linkage", name, element, index); 13122 if (element.hasActiveElement()) { 13123 composeBoolean(t, "Linkage", "active", element.getActiveElement(), -1); 13124 } 13125 if (element.hasAuthor()) { 13126 composeReference(t, "Linkage", "author", element.getAuthor(), -1); 13127 } 13128 for (int i = 0; i < element.getItem().size(); i++) { 13129 composeLinkageItemComponent(t, "Linkage", "item", element.getItem().get(i), i); 13130 } 13131 } 13132 13133 protected void composeLinkageItemComponent(Complex parent, String parentType, String name, Linkage.LinkageItemComponent element, int index) { 13134 if (element == null) 13135 return; 13136 Complex t; 13137 if (Utilities.noString(parentType)) 13138 t = parent; 13139 else { 13140 t = parent.predicate("fhir:"+parentType+'.'+name); 13141 } 13142 composeBackboneElement(t, "item", name, element, index); 13143 if (element.hasTypeElement()) { 13144 composeEnum(t, "LinkageItemComponent", "type", element.getTypeElement(), -1); 13145 } 13146 if (element.hasResource()) { 13147 composeReference(t, "LinkageItemComponent", "resource", element.getResource(), -1); 13148 } 13149 } 13150 13151 protected void composeListResource(Complex parent, String parentType, String name, ListResource element, int index) { 13152 if (element == null) 13153 return; 13154 Complex t; 13155 if (Utilities.noString(parentType)) 13156 t = parent; 13157 else { 13158 t = parent.predicate("fhir:"+parentType+'.'+name); 13159 } 13160 composeDomainResource(t, "List", name, element, index); 13161 for (int i = 0; i < element.getIdentifier().size(); i++) { 13162 composeIdentifier(t, "ListResource", "identifier", element.getIdentifier().get(i), i); 13163 } 13164 if (element.hasStatusElement()) { 13165 composeEnum(t, "ListResource", "status", element.getStatusElement(), -1); 13166 } 13167 if (element.hasModeElement()) { 13168 composeEnum(t, "ListResource", "mode", element.getModeElement(), -1); 13169 } 13170 if (element.hasTitleElement()) { 13171 composeString(t, "ListResource", "title", element.getTitleElement(), -1); 13172 } 13173 if (element.hasCode()) { 13174 composeCodeableConcept(t, "ListResource", "code", element.getCode(), -1); 13175 } 13176 if (element.hasSubject()) { 13177 composeReference(t, "ListResource", "subject", element.getSubject(), -1); 13178 } 13179 if (element.hasEncounter()) { 13180 composeReference(t, "ListResource", "encounter", element.getEncounter(), -1); 13181 } 13182 if (element.hasDateElement()) { 13183 composeDateTime(t, "ListResource", "date", element.getDateElement(), -1); 13184 } 13185 if (element.hasSource()) { 13186 composeReference(t, "ListResource", "source", element.getSource(), -1); 13187 } 13188 if (element.hasOrderedBy()) { 13189 composeCodeableConcept(t, "ListResource", "orderedBy", element.getOrderedBy(), -1); 13190 } 13191 for (int i = 0; i < element.getNote().size(); i++) { 13192 composeAnnotation(t, "ListResource", "note", element.getNote().get(i), i); 13193 } 13194 for (int i = 0; i < element.getEntry().size(); i++) { 13195 composeListResourceEntryComponent(t, "ListResource", "entry", element.getEntry().get(i), i); 13196 } 13197 if (element.hasEmptyReason()) { 13198 composeCodeableConcept(t, "ListResource", "emptyReason", element.getEmptyReason(), -1); 13199 } 13200 } 13201 13202 protected void composeListResourceEntryComponent(Complex parent, String parentType, String name, ListResource.ListResourceEntryComponent element, int index) { 13203 if (element == null) 13204 return; 13205 Complex t; 13206 if (Utilities.noString(parentType)) 13207 t = parent; 13208 else { 13209 t = parent.predicate("fhir:"+parentType+'.'+name); 13210 } 13211 composeBackboneElement(t, "entry", name, element, index); 13212 if (element.hasFlag()) { 13213 composeCodeableConcept(t, "ListResourceEntryComponent", "flag", element.getFlag(), -1); 13214 } 13215 if (element.hasDeletedElement()) { 13216 composeBoolean(t, "ListResourceEntryComponent", "deleted", element.getDeletedElement(), -1); 13217 } 13218 if (element.hasDateElement()) { 13219 composeDateTime(t, "ListResourceEntryComponent", "date", element.getDateElement(), -1); 13220 } 13221 if (element.hasItem()) { 13222 composeReference(t, "ListResourceEntryComponent", "item", element.getItem(), -1); 13223 } 13224 } 13225 13226 protected void composeLocation(Complex parent, String parentType, String name, Location element, int index) { 13227 if (element == null) 13228 return; 13229 Complex t; 13230 if (Utilities.noString(parentType)) 13231 t = parent; 13232 else { 13233 t = parent.predicate("fhir:"+parentType+'.'+name); 13234 } 13235 composeDomainResource(t, "Location", name, element, index); 13236 for (int i = 0; i < element.getIdentifier().size(); i++) { 13237 composeIdentifier(t, "Location", "identifier", element.getIdentifier().get(i), i); 13238 } 13239 if (element.hasStatusElement()) { 13240 composeEnum(t, "Location", "status", element.getStatusElement(), -1); 13241 } 13242 if (element.hasOperationalStatus()) { 13243 composeCoding(t, "Location", "operationalStatus", element.getOperationalStatus(), -1); 13244 } 13245 if (element.hasNameElement()) { 13246 composeString(t, "Location", "name", element.getNameElement(), -1); 13247 } 13248 for (int i = 0; i < element.getAlias().size(); i++) { 13249 composeString(t, "Location", "alias", element.getAlias().get(i), i); 13250 } 13251 if (element.hasDescriptionElement()) { 13252 composeString(t, "Location", "description", element.getDescriptionElement(), -1); 13253 } 13254 if (element.hasModeElement()) { 13255 composeEnum(t, "Location", "mode", element.getModeElement(), -1); 13256 } 13257 for (int i = 0; i < element.getType().size(); i++) { 13258 composeCodeableConcept(t, "Location", "type", element.getType().get(i), i); 13259 } 13260 for (int i = 0; i < element.getTelecom().size(); i++) { 13261 composeContactPoint(t, "Location", "telecom", element.getTelecom().get(i), i); 13262 } 13263 if (element.hasAddress()) { 13264 composeAddress(t, "Location", "address", element.getAddress(), -1); 13265 } 13266 if (element.hasPhysicalType()) { 13267 composeCodeableConcept(t, "Location", "physicalType", element.getPhysicalType(), -1); 13268 } 13269 if (element.hasPosition()) { 13270 composeLocationPositionComponent(t, "Location", "position", element.getPosition(), -1); 13271 } 13272 if (element.hasManagingOrganization()) { 13273 composeReference(t, "Location", "managingOrganization", element.getManagingOrganization(), -1); 13274 } 13275 if (element.hasPartOf()) { 13276 composeReference(t, "Location", "partOf", element.getPartOf(), -1); 13277 } 13278 for (int i = 0; i < element.getHoursOfOperation().size(); i++) { 13279 composeLocationHoursOfOperationComponent(t, "Location", "hoursOfOperation", element.getHoursOfOperation().get(i), i); 13280 } 13281 if (element.hasAvailabilityExceptionsElement()) { 13282 composeString(t, "Location", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1); 13283 } 13284 for (int i = 0; i < element.getEndpoint().size(); i++) { 13285 composeReference(t, "Location", "endpoint", element.getEndpoint().get(i), i); 13286 } 13287 } 13288 13289 protected void composeLocationPositionComponent(Complex parent, String parentType, String name, Location.LocationPositionComponent element, int index) { 13290 if (element == null) 13291 return; 13292 Complex t; 13293 if (Utilities.noString(parentType)) 13294 t = parent; 13295 else { 13296 t = parent.predicate("fhir:"+parentType+'.'+name); 13297 } 13298 composeBackboneElement(t, "position", name, element, index); 13299 if (element.hasLongitudeElement()) { 13300 composeDecimal(t, "LocationPositionComponent", "longitude", element.getLongitudeElement(), -1); 13301 } 13302 if (element.hasLatitudeElement()) { 13303 composeDecimal(t, "LocationPositionComponent", "latitude", element.getLatitudeElement(), -1); 13304 } 13305 if (element.hasAltitudeElement()) { 13306 composeDecimal(t, "LocationPositionComponent", "altitude", element.getAltitudeElement(), -1); 13307 } 13308 } 13309 13310 protected void composeLocationHoursOfOperationComponent(Complex parent, String parentType, String name, Location.LocationHoursOfOperationComponent element, int index) { 13311 if (element == null) 13312 return; 13313 Complex t; 13314 if (Utilities.noString(parentType)) 13315 t = parent; 13316 else { 13317 t = parent.predicate("fhir:"+parentType+'.'+name); 13318 } 13319 composeBackboneElement(t, "hoursOfOperation", name, element, index); 13320 for (int i = 0; i < element.getDaysOfWeek().size(); i++) { 13321 composeEnum(t, "LocationHoursOfOperationComponent", "daysOfWeek", element.getDaysOfWeek().get(i), i); 13322 } 13323 if (element.hasAllDayElement()) { 13324 composeBoolean(t, "LocationHoursOfOperationComponent", "allDay", element.getAllDayElement(), -1); 13325 } 13326 if (element.hasOpeningTimeElement()) { 13327 composeTime(t, "LocationHoursOfOperationComponent", "openingTime", element.getOpeningTimeElement(), -1); 13328 } 13329 if (element.hasClosingTimeElement()) { 13330 composeTime(t, "LocationHoursOfOperationComponent", "closingTime", element.getClosingTimeElement(), -1); 13331 } 13332 } 13333 13334 protected void composeManufacturedItemDefinition(Complex parent, String parentType, String name, ManufacturedItemDefinition element, int index) { 13335 if (element == null) 13336 return; 13337 Complex t; 13338 if (Utilities.noString(parentType)) 13339 t = parent; 13340 else { 13341 t = parent.predicate("fhir:"+parentType+'.'+name); 13342 } 13343 composeDomainResource(t, "ManufacturedItemDefinition", name, element, index); 13344 for (int i = 0; i < element.getIdentifier().size(); i++) { 13345 composeIdentifier(t, "ManufacturedItemDefinition", "identifier", element.getIdentifier().get(i), i); 13346 } 13347 if (element.hasManufacturedDoseForm()) { 13348 composeCodeableConcept(t, "ManufacturedItemDefinition", "manufacturedDoseForm", element.getManufacturedDoseForm(), -1); 13349 } 13350 if (element.hasUnitOfPresentation()) { 13351 composeCodeableConcept(t, "ManufacturedItemDefinition", "unitOfPresentation", element.getUnitOfPresentation(), -1); 13352 } 13353 for (int i = 0; i < element.getManufacturer().size(); i++) { 13354 composeReference(t, "ManufacturedItemDefinition", "manufacturer", element.getManufacturer().get(i), i); 13355 } 13356 for (int i = 0; i < element.getIngredient().size(); i++) { 13357 composeReference(t, "ManufacturedItemDefinition", "ingredient", element.getIngredient().get(i), i); 13358 } 13359 for (int i = 0; i < element.getCharacteristic().size(); i++) { 13360 composeManufacturedItemDefinitionCharacteristicComponent(t, "ManufacturedItemDefinition", "characteristic", element.getCharacteristic().get(i), i); 13361 } 13362 } 13363 13364 protected void composeManufacturedItemDefinitionCharacteristicComponent(Complex parent, String parentType, String name, ManufacturedItemDefinition.ManufacturedItemDefinitionCharacteristicComponent 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, "characteristic", name, element, index); 13374 if (element.hasCode()) { 13375 composeCodeableConcept(t, "ManufacturedItemDefinitionCharacteristicComponent", "code", element.getCode(), -1); 13376 } 13377 if (element.hasValue()) { 13378 composeType(t, "ManufacturedItemDefinitionCharacteristicComponent", "value", element.getValue(), -1); 13379 } 13380 } 13381 13382 protected void composeMeasure(Complex parent, String parentType, String name, Measure 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 composeMetadataResource(t, "Measure", name, element, index); 13392 if (element.hasUrlElement()) { 13393 composeUri(t, "Measure", "url", element.getUrlElement(), -1); 13394 } 13395 for (int i = 0; i < element.getIdentifier().size(); i++) { 13396 composeIdentifier(t, "Measure", "identifier", element.getIdentifier().get(i), i); 13397 } 13398 if (element.hasVersionElement()) { 13399 composeString(t, "Measure", "version", element.getVersionElement(), -1); 13400 } 13401 if (element.hasNameElement()) { 13402 composeString(t, "Measure", "name", element.getNameElement(), -1); 13403 } 13404 if (element.hasTitleElement()) { 13405 composeString(t, "Measure", "title", element.getTitleElement(), -1); 13406 } 13407 if (element.hasSubtitleElement()) { 13408 composeString(t, "Measure", "subtitle", element.getSubtitleElement(), -1); 13409 } 13410 if (element.hasStatusElement()) { 13411 composeEnum(t, "Measure", "status", element.getStatusElement(), -1); 13412 } 13413 if (element.hasExperimentalElement()) { 13414 composeBoolean(t, "Measure", "experimental", element.getExperimentalElement(), -1); 13415 } 13416 if (element.hasSubject()) { 13417 composeType(t, "Measure", "subject", element.getSubject(), -1); 13418 } 13419 if (element.hasDateElement()) { 13420 composeDateTime(t, "Measure", "date", element.getDateElement(), -1); 13421 } 13422 if (element.hasPublisherElement()) { 13423 composeString(t, "Measure", "publisher", element.getPublisherElement(), -1); 13424 } 13425 for (int i = 0; i < element.getContact().size(); i++) { 13426 composeContactDetail(t, "Measure", "contact", element.getContact().get(i), i); 13427 } 13428 if (element.hasDescriptionElement()) { 13429 composeMarkdown(t, "Measure", "description", element.getDescriptionElement(), -1); 13430 } 13431 for (int i = 0; i < element.getUseContext().size(); i++) { 13432 composeUsageContext(t, "Measure", "useContext", element.getUseContext().get(i), i); 13433 } 13434 for (int i = 0; i < element.getJurisdiction().size(); i++) { 13435 composeCodeableConcept(t, "Measure", "jurisdiction", element.getJurisdiction().get(i), i); 13436 } 13437 if (element.hasPurposeElement()) { 13438 composeMarkdown(t, "Measure", "purpose", element.getPurposeElement(), -1); 13439 } 13440 if (element.hasUsageElement()) { 13441 composeString(t, "Measure", "usage", element.getUsageElement(), -1); 13442 } 13443 if (element.hasCopyrightElement()) { 13444 composeMarkdown(t, "Measure", "copyright", element.getCopyrightElement(), -1); 13445 } 13446 if (element.hasApprovalDateElement()) { 13447 composeDate(t, "Measure", "approvalDate", element.getApprovalDateElement(), -1); 13448 } 13449 if (element.hasLastReviewDateElement()) { 13450 composeDate(t, "Measure", "lastReviewDate", element.getLastReviewDateElement(), -1); 13451 } 13452 if (element.hasEffectivePeriod()) { 13453 composePeriod(t, "Measure", "effectivePeriod", element.getEffectivePeriod(), -1); 13454 } 13455 for (int i = 0; i < element.getTopic().size(); i++) { 13456 composeCodeableConcept(t, "Measure", "topic", element.getTopic().get(i), i); 13457 } 13458 for (int i = 0; i < element.getAuthor().size(); i++) { 13459 composeContactDetail(t, "Measure", "author", element.getAuthor().get(i), i); 13460 } 13461 for (int i = 0; i < element.getEditor().size(); i++) { 13462 composeContactDetail(t, "Measure", "editor", element.getEditor().get(i), i); 13463 } 13464 for (int i = 0; i < element.getReviewer().size(); i++) { 13465 composeContactDetail(t, "Measure", "reviewer", element.getReviewer().get(i), i); 13466 } 13467 for (int i = 0; i < element.getEndorser().size(); i++) { 13468 composeContactDetail(t, "Measure", "endorser", element.getEndorser().get(i), i); 13469 } 13470 for (int i = 0; i < element.getRelatedArtifact().size(); i++) { 13471 composeRelatedArtifact(t, "Measure", "relatedArtifact", element.getRelatedArtifact().get(i), i); 13472 } 13473 for (int i = 0; i < element.getLibrary().size(); i++) { 13474 composeCanonical(t, "Measure", "library", element.getLibrary().get(i), i); 13475 } 13476 if (element.hasDisclaimerElement()) { 13477 composeMarkdown(t, "Measure", "disclaimer", element.getDisclaimerElement(), -1); 13478 } 13479 if (element.hasScoring()) { 13480 composeCodeableConcept(t, "Measure", "scoring", element.getScoring(), -1); 13481 } 13482 if (element.hasCompositeScoring()) { 13483 composeCodeableConcept(t, "Measure", "compositeScoring", element.getCompositeScoring(), -1); 13484 } 13485 for (int i = 0; i < element.getType().size(); i++) { 13486 composeCodeableConcept(t, "Measure", "type", element.getType().get(i), i); 13487 } 13488 if (element.hasRiskAdjustmentElement()) { 13489 composeString(t, "Measure", "riskAdjustment", element.getRiskAdjustmentElement(), -1); 13490 } 13491 if (element.hasRateAggregationElement()) { 13492 composeString(t, "Measure", "rateAggregation", element.getRateAggregationElement(), -1); 13493 } 13494 if (element.hasRationaleElement()) { 13495 composeMarkdown(t, "Measure", "rationale", element.getRationaleElement(), -1); 13496 } 13497 if (element.hasClinicalRecommendationStatementElement()) { 13498 composeMarkdown(t, "Measure", "clinicalRecommendationStatement", element.getClinicalRecommendationStatementElement(), -1); 13499 } 13500 if (element.hasImprovementNotation()) { 13501 composeCodeableConcept(t, "Measure", "improvementNotation", element.getImprovementNotation(), -1); 13502 } 13503 for (int i = 0; i < element.getDefinition().size(); i++) { 13504 composeMarkdown(t, "Measure", "definition", element.getDefinition().get(i), i); 13505 } 13506 if (element.hasGuidanceElement()) { 13507 composeMarkdown(t, "Measure", "guidance", element.getGuidanceElement(), -1); 13508 } 13509 for (int i = 0; i < element.getGroup().size(); i++) { 13510 composeMeasureGroupComponent(t, "Measure", "group", element.getGroup().get(i), i); 13511 } 13512 for (int i = 0; i < element.getSupplementalData().size(); i++) { 13513 composeMeasureSupplementalDataComponent(t, "Measure", "supplementalData", element.getSupplementalData().get(i), i); 13514 } 13515 } 13516 13517 protected void composeMeasureGroupComponent(Complex parent, String parentType, String name, Measure.MeasureGroupComponent element, int index) { 13518 if (element == null) 13519 return; 13520 Complex t; 13521 if (Utilities.noString(parentType)) 13522 t = parent; 13523 else { 13524 t = parent.predicate("fhir:"+parentType+'.'+name); 13525 } 13526 composeBackboneElement(t, "group", name, element, index); 13527 if (element.hasCode()) { 13528 composeCodeableConcept(t, "MeasureGroupComponent", "code", element.getCode(), -1); 13529 } 13530 if (element.hasDescriptionElement()) { 13531 composeString(t, "MeasureGroupComponent", "description", element.getDescriptionElement(), -1); 13532 } 13533 for (int i = 0; i < element.getPopulation().size(); i++) { 13534 composeMeasureGroupPopulationComponent(t, "MeasureGroupComponent", "population", element.getPopulation().get(i), i); 13535 } 13536 for (int i = 0; i < element.getStratifier().size(); i++) { 13537 composeMeasureGroupStratifierComponent(t, "MeasureGroupComponent", "stratifier", element.getStratifier().get(i), i); 13538 } 13539 } 13540 13541 protected void composeMeasureGroupPopulationComponent(Complex parent, String parentType, String name, Measure.MeasureGroupPopulationComponent element, int index) { 13542 if (element == null) 13543 return; 13544 Complex t; 13545 if (Utilities.noString(parentType)) 13546 t = parent; 13547 else { 13548 t = parent.predicate("fhir:"+parentType+'.'+name); 13549 } 13550 composeBackboneElement(t, "population", name, element, index); 13551 if (element.hasCode()) { 13552 composeCodeableConcept(t, "MeasureGroupPopulationComponent", "code", element.getCode(), -1); 13553 } 13554 if (element.hasDescriptionElement()) { 13555 composeString(t, "MeasureGroupPopulationComponent", "description", element.getDescriptionElement(), -1); 13556 } 13557 if (element.hasCriteria()) { 13558 composeExpression(t, "MeasureGroupPopulationComponent", "criteria", element.getCriteria(), -1); 13559 } 13560 } 13561 13562 protected void composeMeasureGroupStratifierComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponent element, int index) { 13563 if (element == null) 13564 return; 13565 Complex t; 13566 if (Utilities.noString(parentType)) 13567 t = parent; 13568 else { 13569 t = parent.predicate("fhir:"+parentType+'.'+name); 13570 } 13571 composeBackboneElement(t, "stratifier", name, element, index); 13572 if (element.hasCode()) { 13573 composeCodeableConcept(t, "MeasureGroupStratifierComponent", "code", element.getCode(), -1); 13574 } 13575 if (element.hasDescriptionElement()) { 13576 composeString(t, "MeasureGroupStratifierComponent", "description", element.getDescriptionElement(), -1); 13577 } 13578 if (element.hasCriteria()) { 13579 composeExpression(t, "MeasureGroupStratifierComponent", "criteria", element.getCriteria(), -1); 13580 } 13581 for (int i = 0; i < element.getComponent().size(); i++) { 13582 composeMeasureGroupStratifierComponentComponent(t, "MeasureGroupStratifierComponent", "component", element.getComponent().get(i), i); 13583 } 13584 } 13585 13586 protected void composeMeasureGroupStratifierComponentComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponentComponent 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, "component", name, element, index); 13596 if (element.hasCode()) { 13597 composeCodeableConcept(t, "MeasureGroupStratifierComponentComponent", "code", element.getCode(), -1); 13598 } 13599 if (element.hasDescriptionElement()) { 13600 composeString(t, "MeasureGroupStratifierComponentComponent", "description", element.getDescriptionElement(), -1); 13601 } 13602 if (element.hasCriteria()) { 13603 composeExpression(t, "MeasureGroupStratifierComponentComponent", "criteria", element.getCriteria(), -1); 13604 } 13605 } 13606 13607 protected void composeMeasureSupplementalDataComponent(Complex parent, String parentType, String name, Measure.MeasureSupplementalDataComponent element, int index) { 13608 if (element == null) 13609 return; 13610 Complex t; 13611 if (Utilities.noString(parentType)) 13612 t = parent; 13613 else { 13614 t = parent.predicate("fhir:"+parentType+'.'+name); 13615 } 13616 composeBackboneElement(t, "supplementalData", name, element, index); 13617 if (element.hasCode()) { 13618 composeCodeableConcept(t, "MeasureSupplementalDataComponent", "code", element.getCode(), -1); 13619 } 13620 for (int i = 0; i < element.getUsage().size(); i++) { 13621 composeCodeableConcept(t, "MeasureSupplementalDataComponent", "usage", element.getUsage().get(i), i); 13622 } 13623 if (element.hasDescriptionElement()) { 13624 composeString(t, "MeasureSupplementalDataComponent", "description", element.getDescriptionElement(), -1); 13625 } 13626 if (element.hasCriteria()) { 13627 composeExpression(t, "MeasureSupplementalDataComponent", "criteria", element.getCriteria(), -1); 13628 } 13629 } 13630 13631 protected void composeMeasureReport(Complex parent, String parentType, String name, MeasureReport element, int index) { 13632 if (element == null) 13633 return; 13634 Complex t; 13635 if (Utilities.noString(parentType)) 13636 t = parent; 13637 else { 13638 t = parent.predicate("fhir:"+parentType+'.'+name); 13639 } 13640 composeDomainResource(t, "MeasureReport", name, element, index); 13641 for (int i = 0; i < element.getIdentifier().size(); i++) { 13642 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier().get(i), i); 13643 } 13644 if (element.hasStatusElement()) { 13645 composeEnum(t, "MeasureReport", "status", element.getStatusElement(), -1); 13646 } 13647 if (element.hasTypeElement()) { 13648 composeEnum(t, "MeasureReport", "type", element.getTypeElement(), -1); 13649 } 13650 if (element.hasMeasureElement()) { 13651 composeCanonical(t, "MeasureReport", "measure", element.getMeasureElement(), -1); 13652 } 13653 if (element.hasSubject()) { 13654 composeReference(t, "MeasureReport", "subject", element.getSubject(), -1); 13655 } 13656 if (element.hasDateElement()) { 13657 composeDateTime(t, "MeasureReport", "date", element.getDateElement(), -1); 13658 } 13659 if (element.hasReporter()) { 13660 composeReference(t, "MeasureReport", "reporter", element.getReporter(), -1); 13661 } 13662 if (element.hasPeriod()) { 13663 composePeriod(t, "MeasureReport", "period", element.getPeriod(), -1); 13664 } 13665 if (element.hasImprovementNotation()) { 13666 composeCodeableConcept(t, "MeasureReport", "improvementNotation", element.getImprovementNotation(), -1); 13667 } 13668 for (int i = 0; i < element.getGroup().size(); i++) { 13669 composeMeasureReportGroupComponent(t, "MeasureReport", "group", element.getGroup().get(i), i); 13670 } 13671 for (int i = 0; i < element.getEvaluatedResource().size(); i++) { 13672 composeReference(t, "MeasureReport", "evaluatedResource", element.getEvaluatedResource().get(i), i); 13673 } 13674 } 13675 13676 protected void composeMeasureReportGroupComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupComponent element, int index) { 13677 if (element == null) 13678 return; 13679 Complex t; 13680 if (Utilities.noString(parentType)) 13681 t = parent; 13682 else { 13683 t = parent.predicate("fhir:"+parentType+'.'+name); 13684 } 13685 composeBackboneElement(t, "group", name, element, index); 13686 if (element.hasCode()) { 13687 composeCodeableConcept(t, "MeasureReportGroupComponent", "code", element.getCode(), -1); 13688 } 13689 for (int i = 0; i < element.getPopulation().size(); i++) { 13690 composeMeasureReportGroupPopulationComponent(t, "MeasureReportGroupComponent", "population", element.getPopulation().get(i), i); 13691 } 13692 if (element.hasMeasureScore()) { 13693 composeQuantity(t, "MeasureReportGroupComponent", "measureScore", element.getMeasureScore(), -1); 13694 } 13695 for (int i = 0; i < element.getStratifier().size(); i++) { 13696 composeMeasureReportGroupStratifierComponent(t, "MeasureReportGroupComponent", "stratifier", element.getStratifier().get(i), i); 13697 } 13698 } 13699 13700 protected void composeMeasureReportGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupPopulationComponent element, int index) { 13701 if (element == null) 13702 return; 13703 Complex t; 13704 if (Utilities.noString(parentType)) 13705 t = parent; 13706 else { 13707 t = parent.predicate("fhir:"+parentType+'.'+name); 13708 } 13709 composeBackboneElement(t, "population", name, element, index); 13710 if (element.hasCode()) { 13711 composeCodeableConcept(t, "MeasureReportGroupPopulationComponent", "code", element.getCode(), -1); 13712 } 13713 if (element.hasCountElement()) { 13714 composeInteger(t, "MeasureReportGroupPopulationComponent", "count", element.getCountElement(), -1); 13715 } 13716 if (element.hasSubjectResults()) { 13717 composeReference(t, "MeasureReportGroupPopulationComponent", "subjectResults", element.getSubjectResults(), -1); 13718 } 13719 } 13720 13721 protected void composeMeasureReportGroupStratifierComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupStratifierComponent element, int index) { 13722 if (element == null) 13723 return; 13724 Complex t; 13725 if (Utilities.noString(parentType)) 13726 t = parent; 13727 else { 13728 t = parent.predicate("fhir:"+parentType+'.'+name); 13729 } 13730 composeBackboneElement(t, "stratifier", name, element, index); 13731 for (int i = 0; i < element.getCode().size(); i++) { 13732 composeCodeableConcept(t, "MeasureReportGroupStratifierComponent", "code", element.getCode().get(i), i); 13733 } 13734 for (int i = 0; i < element.getStratum().size(); i++) { 13735 composeMeasureReportStratifierGroupComponent(t, "MeasureReportGroupStratifierComponent", "stratum", element.getStratum().get(i), i); 13736 } 13737 } 13738 13739 protected void composeMeasureReportStratifierGroupComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupComponent element, int index) { 13740 if (element == null) 13741 return; 13742 Complex t; 13743 if (Utilities.noString(parentType)) 13744 t = parent; 13745 else { 13746 t = parent.predicate("fhir:"+parentType+'.'+name); 13747 } 13748 composeBackboneElement(t, "stratum", name, element, index); 13749 if (element.hasValue()) { 13750 composeCodeableConcept(t, "StratifierGroupComponent", "value", element.getValue(), -1); 13751 } 13752 for (int i = 0; i < element.getComponent().size(); i++) { 13753 composeMeasureReportStratifierGroupComponentComponent(t, "StratifierGroupComponent", "component", element.getComponent().get(i), i); 13754 } 13755 for (int i = 0; i < element.getPopulation().size(); i++) { 13756 composeMeasureReportStratifierGroupPopulationComponent(t, "StratifierGroupComponent", "population", element.getPopulation().get(i), i); 13757 } 13758 if (element.hasMeasureScore()) { 13759 composeQuantity(t, "StratifierGroupComponent", "measureScore", element.getMeasureScore(), -1); 13760 } 13761 } 13762 13763 protected void composeMeasureReportStratifierGroupComponentComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupComponentComponent element, int index) { 13764 if (element == null) 13765 return; 13766 Complex t; 13767 if (Utilities.noString(parentType)) 13768 t = parent; 13769 else { 13770 t = parent.predicate("fhir:"+parentType+'.'+name); 13771 } 13772 composeBackboneElement(t, "component", name, element, index); 13773 if (element.hasCode()) { 13774 composeCodeableConcept(t, "StratifierGroupComponentComponent", "code", element.getCode(), -1); 13775 } 13776 if (element.hasValue()) { 13777 composeCodeableConcept(t, "StratifierGroupComponentComponent", "value", element.getValue(), -1); 13778 } 13779 } 13780 13781 protected void composeMeasureReportStratifierGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupPopulationComponent element, int index) { 13782 if (element == null) 13783 return; 13784 Complex t; 13785 if (Utilities.noString(parentType)) 13786 t = parent; 13787 else { 13788 t = parent.predicate("fhir:"+parentType+'.'+name); 13789 } 13790 composeBackboneElement(t, "population", name, element, index); 13791 if (element.hasCode()) { 13792 composeCodeableConcept(t, "StratifierGroupPopulationComponent", "code", element.getCode(), -1); 13793 } 13794 if (element.hasCountElement()) { 13795 composeInteger(t, "StratifierGroupPopulationComponent", "count", element.getCountElement(), -1); 13796 } 13797 if (element.hasSubjectResults()) { 13798 composeReference(t, "StratifierGroupPopulationComponent", "subjectResults", element.getSubjectResults(), -1); 13799 } 13800 } 13801 13802 protected void composeMedication(Complex parent, String parentType, String name, Medication element, int index) { 13803 if (element == null) 13804 return; 13805 Complex t; 13806 if (Utilities.noString(parentType)) 13807 t = parent; 13808 else { 13809 t = parent.predicate("fhir:"+parentType+'.'+name); 13810 } 13811 composeDomainResource(t, "Medication", name, element, index); 13812 for (int i = 0; i < element.getIdentifier().size(); i++) { 13813 composeIdentifier(t, "Medication", "identifier", element.getIdentifier().get(i), i); 13814 } 13815 if (element.hasCode()) { 13816 composeCodeableConcept(t, "Medication", "code", element.getCode(), -1); 13817 } 13818 if (element.hasStatusElement()) { 13819 composeEnum(t, "Medication", "status", element.getStatusElement(), -1); 13820 } 13821 if (element.hasManufacturer()) { 13822 composeReference(t, "Medication", "manufacturer", element.getManufacturer(), -1); 13823 } 13824 if (element.hasDoseForm()) { 13825 composeCodeableConcept(t, "Medication", "doseForm", element.getDoseForm(), -1); 13826 } 13827 if (element.hasAmount()) { 13828 composeRatio(t, "Medication", "amount", element.getAmount(), -1); 13829 } 13830 for (int i = 0; i < element.getIngredient().size(); i++) { 13831 composeMedicationIngredientComponent(t, "Medication", "ingredient", element.getIngredient().get(i), i); 13832 } 13833 if (element.hasBatch()) { 13834 composeMedicationBatchComponent(t, "Medication", "batch", element.getBatch(), -1); 13835 } 13836 } 13837 13838 protected void composeMedicationIngredientComponent(Complex parent, String parentType, String name, Medication.MedicationIngredientComponent 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, "ingredient", name, element, index); 13848 if (element.hasItem()) { 13849 composeType(t, "MedicationIngredientComponent", "item", element.getItem(), -1); 13850 } 13851 if (element.hasIsActiveElement()) { 13852 composeBoolean(t, "MedicationIngredientComponent", "isActive", element.getIsActiveElement(), -1); 13853 } 13854 if (element.hasStrength()) { 13855 composeType(t, "MedicationIngredientComponent", "strength", element.getStrength(), -1); 13856 } 13857 } 13858 13859 protected void composeMedicationBatchComponent(Complex parent, String parentType, String name, Medication.MedicationBatchComponent element, int index) { 13860 if (element == null) 13861 return; 13862 Complex t; 13863 if (Utilities.noString(parentType)) 13864 t = parent; 13865 else { 13866 t = parent.predicate("fhir:"+parentType+'.'+name); 13867 } 13868 composeBackboneElement(t, "batch", name, element, index); 13869 if (element.hasLotNumberElement()) { 13870 composeString(t, "MedicationBatchComponent", "lotNumber", element.getLotNumberElement(), -1); 13871 } 13872 if (element.hasExpirationDateElement()) { 13873 composeDateTime(t, "MedicationBatchComponent", "expirationDate", element.getExpirationDateElement(), -1); 13874 } 13875 } 13876 13877 protected void composeMedicationAdministration(Complex parent, String parentType, String name, MedicationAdministration element, int index) { 13878 if (element == null) 13879 return; 13880 Complex t; 13881 if (Utilities.noString(parentType)) 13882 t = parent; 13883 else { 13884 t = parent.predicate("fhir:"+parentType+'.'+name); 13885 } 13886 composeDomainResource(t, "MedicationAdministration", name, element, index); 13887 for (int i = 0; i < element.getIdentifier().size(); i++) { 13888 composeIdentifier(t, "MedicationAdministration", "identifier", element.getIdentifier().get(i), i); 13889 } 13890 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) { 13891 composeCanonical(t, "MedicationAdministration", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 13892 } 13893 for (int i = 0; i < element.getInstantiatesUri().size(); i++) { 13894 composeUri(t, "MedicationAdministration", "instantiatesUri", element.getInstantiatesUri().get(i), i); 13895 } 13896 for (int i = 0; i < element.getBasedOn().size(); i++) { 13897 composeReference(t, "MedicationAdministration", "basedOn", element.getBasedOn().get(i), i); 13898 } 13899 for (int i = 0; i < element.getPartOf().size(); i++) { 13900 composeReference(t, "MedicationAdministration", "partOf", element.getPartOf().get(i), i); 13901 } 13902 if (element.hasStatusElement()) { 13903 composeEnum(t, "MedicationAdministration", "status", element.getStatusElement(), -1); 13904 } 13905 for (int i = 0; i < element.getStatusReason().size(); i++) { 13906 composeCodeableConcept(t, "MedicationAdministration", "statusReason", element.getStatusReason().get(i), i); 13907 } 13908 for (int i = 0; i < element.getCategory().size(); i++) { 13909 composeCodeableConcept(t, "MedicationAdministration", "category", element.getCategory().get(i), i); 13910 } 13911 if (element.hasMedication()) { 13912 composeType(t, "MedicationAdministration", "medication", element.getMedication(), -1); 13913 } 13914 if (element.hasSubject()) { 13915 composeReference(t, "MedicationAdministration", "subject", element.getSubject(), -1); 13916 } 13917 if (element.hasEncounter()) { 13918 composeReference(t, "MedicationAdministration", "encounter", element.getEncounter(), -1); 13919 } 13920 for (int i = 0; i < element.getSupportingInformation().size(); i++) { 13921 composeReference(t, "MedicationAdministration", "supportingInformation", element.getSupportingInformation().get(i), i); 13922 } 13923 if (element.hasOccurence()) { 13924 composeType(t, "MedicationAdministration", "occurence", element.getOccurence(), -1); 13925 } 13926 if (element.hasRecordedElement()) { 13927 composeDateTime(t, "MedicationAdministration", "recorded", element.getRecordedElement(), -1); 13928 } 13929 for (int i = 0; i < element.getPerformer().size(); i++) { 13930 composeMedicationAdministrationPerformerComponent(t, "MedicationAdministration", "performer", element.getPerformer().get(i), i); 13931 } 13932 for (int i = 0; i < element.getReason().size(); i++) { 13933 composeCodeableReference(t, "MedicationAdministration", "reason", element.getReason().get(i), i); 13934 } 13935 if (element.hasRequest()) { 13936 composeReference(t, "MedicationAdministration", "request", element.getRequest(), -1); 13937 } 13938 for (int i = 0; i < element.getDevice().size(); i++) { 13939 composeReference(t, "MedicationAdministration", "device", element.getDevice().get(i), i); 13940 } 13941 for (int i = 0; i < element.getNote().size(); i++) { 13942 composeAnnotation(t, "MedicationAdministration", "note", element.getNote().get(i), i); 13943 } 13944 if (element.hasDosage()) { 13945 composeMedicationAdministrationDosageComponent(t, "MedicationAdministration", "dosage", element.getDosage(), -1); 13946 } 13947 for (int i = 0; i < element.getEventHistory().size(); i++) { 13948 composeReference(t, "MedicationAdministration", "eventHistory", element.getEventHistory().get(i), i); 13949 } 13950 } 13951 13952 protected void composeMedicationAdministrationPerformerComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationPerformerComponent 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 composeBackboneElement(t, "performer", name, element, index); 13962 if (element.hasFunction()) { 13963 composeCodeableConcept(t, "MedicationAdministrationPerformerComponent", "function", element.getFunction(), -1); 13964 } 13965 if (element.hasActor()) { 13966 composeReference(t, "MedicationAdministrationPerformerComponent", "actor", element.getActor(), -1); 13967 } 13968 } 13969 13970 protected void composeMedicationAdministrationDosageComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationDosageComponent element, int index) { 13971 if (element == null) 13972 return; 13973 Complex t; 13974 if (Utilities.noString(parentType)) 13975 t = parent; 13976 else { 13977 t = parent.predicate("fhir:"+parentType+'.'+name); 13978 } 13979 composeBackboneElement(t, "dosage", name, element, index); 13980 if (element.hasTextElement()) { 13981 composeString(t, "MedicationAdministrationDosageComponent", "text", element.getTextElement(), -1); 13982 } 13983 if (element.hasSite()) { 13984 composeCodeableConcept(t, "MedicationAdministrationDosageComponent", "site", element.getSite(), -1); 13985 } 13986 if (element.hasRoute()) { 13987 composeCodeableConcept(t, "MedicationAdministrationDosageComponent", "route", element.getRoute(), -1); 13988 } 13989 if (element.hasMethod()) { 13990 composeCodeableConcept(t, "MedicationAdministrationDosageComponent", "method", element.getMethod(), -1); 13991 } 13992 if (element.hasDose()) { 13993 composeQuantity(t, "MedicationAdministrationDosageComponent", "dose", element.getDose(), -1); 13994 } 13995 if (element.hasRate()) { 13996 composeType(t, "MedicationAdministrationDosageComponent", "rate", element.getRate(), -1); 13997 } 13998 } 13999 14000 protected void composeMedicationDispense(Complex parent, String parentType, String name, MedicationDispense element, int index) { 14001 if (element == null) 14002 return; 14003 Complex t; 14004 if (Utilities.noString(parentType)) 14005 t = parent; 14006 else { 14007 t = parent.predicate("fhir:"+parentType+'.'+name); 14008 } 14009 composeDomainResource(t, "MedicationDispense", name, element, index); 14010 for (int i = 0; i < element.getIdentifier().size(); i++) { 14011 composeIdentifier(t, "MedicationDispense", "identifier", element.getIdentifier().get(i), i); 14012 } 14013 for (int i = 0; i < element.getBasedOn().size(); i++) { 14014 composeReference(t, "MedicationDispense", "basedOn", element.getBasedOn().get(i), i); 14015 } 14016 for (int i = 0; i < element.getPartOf().size(); i++) { 14017 composeReference(t, "MedicationDispense", "partOf", element.getPartOf().get(i), i); 14018 } 14019 if (element.hasStatusElement()) { 14020 composeEnum(t, "MedicationDispense", "status", element.getStatusElement(), -1); 14021 } 14022 if (element.hasStatusReason()) { 14023 composeType(t, "MedicationDispense", "statusReason", element.getStatusReason(), -1); 14024 } 14025 for (int i = 0; i < element.getCategory().size(); i++) { 14026 composeCodeableConcept(t, "MedicationDispense", "category", element.getCategory().get(i), i); 14027 } 14028 if (element.hasMedication()) { 14029 composeType(t, "MedicationDispense", "medication", element.getMedication(), -1); 14030 } 14031 if (element.hasSubject()) { 14032 composeReference(t, "MedicationDispense", "subject", element.getSubject(), -1); 14033 } 14034 if (element.hasEncounter()) { 14035 composeReference(t, "MedicationDispense", "encounter", element.getEncounter(), -1); 14036 } 14037 for (int i = 0; i < element.getSupportingInformation().size(); i++) { 14038 composeReference(t, "MedicationDispense", "supportingInformation", element.getSupportingInformation().get(i), i); 14039 } 14040 for (int i = 0; i < element.getPerformer().size(); i++) { 14041 composeMedicationDispensePerformerComponent(t, "MedicationDispense", "performer", element.getPerformer().get(i), i); 14042 } 14043 if (element.hasLocation()) { 14044 composeReference(t, "MedicationDispense", "location", element.getLocation(), -1); 14045 } 14046 for (int i = 0; i < element.getAuthorizingPrescription().size(); i++) { 14047 composeReference(t, "MedicationDispense", "authorizingPrescription", element.getAuthorizingPrescription().get(i), i); 14048 } 14049 if (element.hasType()) { 14050 composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1); 14051 } 14052 if (element.hasQuantity()) { 14053 composeQuantity(t, "MedicationDispense", "quantity", element.getQuantity(), -1); 14054 } 14055 if (element.hasDaysSupply()) { 14056 composeQuantity(t, "MedicationDispense", "daysSupply", element.getDaysSupply(), -1); 14057 } 14058 if (element.hasWhenPreparedElement()) { 14059 composeDateTime(t, "MedicationDispense", "whenPrepared", element.getWhenPreparedElement(), -1); 14060 } 14061 if (element.hasWhenHandedOverElement()) { 14062 composeDateTime(t, "MedicationDispense", "whenHandedOver", element.getWhenHandedOverElement(), -1); 14063 } 14064 if (element.hasDestination()) { 14065 composeReference(t, "MedicationDispense", "destination", element.getDestination(), -1); 14066 } 14067 for (int i = 0; i < element.getReceiver().size(); i++) { 14068 composeReference(t, "MedicationDispense", "receiver", element.getReceiver().get(i), i); 14069 } 14070 for (int i = 0; i < element.getNote().size(); i++) { 14071 composeAnnotation(t, "MedicationDispense", "note", element.getNote().get(i), i); 14072 } 14073 if (element.hasRenderedDosageInstructionElement()) { 14074 composeString(t, "MedicationDispense", "renderedDosageInstruction", element.getRenderedDosageInstructionElement(), -1); 14075 } 14076 for (int i = 0; i < element.getDosageInstruction().size(); i++) { 14077 composeDosage(t, "MedicationDispense", "dosageInstruction", element.getDosageInstruction().get(i), i); 14078 } 14079 if (element.hasSubstitution()) { 14080 composeMedicationDispenseSubstitutionComponent(t, "MedicationDispense", "substitution", element.getSubstitution(), -1); 14081 } 14082 for (int i = 0; i < element.getDetectedIssue().size(); i++) { 14083 composeReference(t, "MedicationDispense", "detectedIssue", element.getDetectedIssue().get(i), i); 14084 } 14085 for (int i = 0; i < element.getEventHistory().size(); i++) { 14086 composeReference(t, "MedicationDispense", "eventHistory", element.getEventHistory().get(i), i); 14087 } 14088 } 14089 14090 protected void composeMedicationDispensePerformerComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispensePerformerComponent element, int index) { 14091 if (element == null) 14092 return; 14093 Complex t; 14094 if (Utilities.noString(parentType)) 14095 t = parent; 14096 else { 14097 t = parent.predicate("fhir:"+parentType+'.'+name); 14098 } 14099 composeBackboneElement(t, "performer", name, element, index); 14100 if (element.hasFunction()) { 14101 composeCodeableConcept(t, "MedicationDispensePerformerComponent", "function", element.getFunction(), -1); 14102 } 14103 if (element.hasActor()) { 14104 composeReference(t, "MedicationDispensePerformerComponent", "actor", element.getActor(), -1); 14105 } 14106 } 14107 14108 protected void composeMedicationDispenseSubstitutionComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispenseSubstitutionComponent element, int index) { 14109 if (element == null) 14110 return; 14111 Complex t; 14112 if (Utilities.noString(parentType)) 14113 t = parent; 14114 else { 14115 t = parent.predicate("fhir:"+parentType+'.'+name); 14116 } 14117 composeBackboneElement(t, "substitution", name, element, index); 14118 if (element.hasWasSubstitutedElement()) { 14119 composeBoolean(t, "MedicationDispenseSubstitutionComponent", "wasSubstituted", element.getWasSubstitutedElement(), -1); 14120 } 14121 if (element.hasType()) { 14122 composeCodeableConcept(t, "MedicationDispenseSubstitutionComponent", "type", element.getType(), -1); 14123 } 14124 for (int i = 0; i < element.getReason().size(); i++) { 14125 composeCodeableConcept(t, "MedicationDispenseSubstitutionComponent", "reason", element.getReason().get(i), i); 14126 } 14127 if (element.hasResponsibleParty()) { 14128 composeReference(t, "MedicationDispenseSubstitutionComponent", "responsibleParty", element.getResponsibleParty(), -1); 14129 } 14130 } 14131 14132 protected void composeMedicationKnowledge(Complex parent, String parentType, String name, MedicationKnowledge element, int index) { 14133 if (element == null) 14134 return; 14135 Complex t; 14136 if (Utilities.noString(parentType)) 14137 t = parent; 14138 else { 14139 t = parent.predicate("fhir:"+parentType+'.'+name); 14140 } 14141 composeDomainResource(t, "MedicationKnowledge", name, element, index); 14142 for (int i = 0; i < element.getIdentifier().size(); i++) { 14143 composeIdentifier(t, "MedicationKnowledge", "identifier", element.getIdentifier().get(i), i); 14144 } 14145 if (element.hasCode()) { 14146 composeCodeableConcept(t, "MedicationKnowledge", "code", element.getCode(), -1); 14147 } 14148 if (element.hasStatusElement()) { 14149 composeEnum(t, "MedicationKnowledge", "status", element.getStatusElement(), -1); 14150 } 14151 if (element.hasManufacturer()) { 14152 composeReference(t, "MedicationKnowledge", "manufacturer", element.getManufacturer(), -1); 14153 } 14154 if (element.hasDoseForm()) { 14155 composeCodeableConcept(t, "MedicationKnowledge", "doseForm", element.getDoseForm(), -1); 14156 } 14157 if (element.hasAmount()) { 14158 composeQuantity(t, "MedicationKnowledge", "amount", element.getAmount(), -1); 14159 } 14160 for (int i = 0; i < element.getSynonym().size(); i++) { 14161 composeString(t, "MedicationKnowledge", "synonym", element.getSynonym().get(i), i); 14162 } 14163 for (int i = 0; i < element.getRelatedMedicationKnowledge().size(); i++) { 14164 composeMedicationKnowledgeRelatedMedicationKnowledgeComponent(t, "MedicationKnowledge", "relatedMedicationKnowledge", element.getRelatedMedicationKnowledge().get(i), i); 14165 } 14166 for (int i = 0; i < element.getAssociatedMedication().size(); i++) { 14167 composeReference(t, "MedicationKnowledge", "associatedMedication", element.getAssociatedMedication().get(i), i); 14168 } 14169 for (int i = 0; i < element.getProductType().size(); i++) { 14170 composeCodeableConcept(t, "MedicationKnowledge", "productType", element.getProductType().get(i), i); 14171 } 14172 for (int i = 0; i < element.getMonograph().size(); i++) { 14173 composeMedicationKnowledgeMonographComponent(t, "MedicationKnowledge", "monograph", element.getMonograph().get(i), i); 14174 } 14175 for (int i = 0; i < element.getIngredient().size(); i++) { 14176 composeMedicationKnowledgeIngredientComponent(t, "MedicationKnowledge", "ingredient", element.getIngredient().get(i), i); 14177 } 14178 for (int i = 0; i < element.getDevice().size(); i++) { 14179 composeReference(t, "MedicationKnowledge", "device", element.getDevice().get(i), i); 14180 } 14181 if (element.hasPreparationInstructionElement()) { 14182 composeMarkdown(t, "MedicationKnowledge", "preparationInstruction", element.getPreparationInstructionElement(), -1); 14183 } 14184 for (int i = 0; i < element.getIntendedRoute().size(); i++) { 14185 composeCodeableConcept(t, "MedicationKnowledge", "intendedRoute", element.getIntendedRoute().get(i), i); 14186 } 14187 for (int i = 0; i < element.getCost().size(); i++) { 14188 composeMedicationKnowledgeCostComponent(t, "MedicationKnowledge", "cost", element.getCost().get(i), i); 14189 } 14190 for (int i = 0; i < element.getMonitoringProgram().size(); i++) { 14191 composeMedicationKnowledgeMonitoringProgramComponent(t, "MedicationKnowledge", "monitoringProgram", element.getMonitoringProgram().get(i), i); 14192 } 14193 for (int i = 0; i < element.getAdministrationGuideline().size(); i++) { 14194 composeMedicationKnowledgeAdministrationGuidelineComponent(t, "MedicationKnowledge", "administrationGuideline", element.getAdministrationGuideline().get(i), i); 14195 } 14196 for (int i = 0; i < element.getMedicineClassification().size(); i++) { 14197 composeMedicationKnowledgeMedicineClassificationComponent(t, "MedicationKnowledge", "medicineClassification", element.getMedicineClassification().get(i), i); 14198 } 14199 if (element.hasPackaging()) { 14200 composeMedicationKnowledgePackagingComponent(t, "MedicationKnowledge", "packaging", element.getPackaging(), -1); 14201 } 14202 for (int i = 0; i < element.getDrugCharacteristic().size(); i++) { 14203 composeMedicationKnowledgeDrugCharacteristicComponent(t, "MedicationKnowledge", "drugCharacteristic", element.getDrugCharacteristic().get(i), i); 14204 } 14205 for (int i = 0; i < element.getClinicalUseIssue().size(); i++) { 14206 composeReference(t, "MedicationKnowledge", "clinicalUseIssue", element.getClinicalUseIssue().get(i), i); 14207 } 14208 for (int i = 0; i < element.getRegulatory().size(); i++) { 14209 composeMedicationKnowledgeRegulatoryComponent(t, "MedicationKnowledge", "regulatory", element.getRegulatory().get(i), i); 14210 } 14211 for (int i = 0; i < element.getKineticCharacteristic().size(); i++) { 14212 composeMedicationKnowledgeKineticCharacteristicComponent(t, "MedicationKnowledge", "kineticCharacteristic", element.getKineticCharacteristic().get(i), i); 14213 } 14214 } 14215 14216 protected void composeMedicationKnowledgeRelatedMedicationKnowledgeComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRelatedMedicationKnowledgeComponent element, int index) { 14217 if (element == null) 14218 return; 14219 Complex t; 14220 if (Utilities.noString(parentType)) 14221 t = parent; 14222 else { 14223 t = parent.predicate("fhir:"+parentType+'.'+name); 14224 } 14225 composeBackboneElement(t, "relatedMedicationKnowledge", name, element, index); 14226 if (element.hasType()) { 14227 composeCodeableConcept(t, "MedicationKnowledgeRelatedMedicationKnowledgeComponent", "type", element.getType(), -1); 14228 } 14229 for (int i = 0; i < element.getReference().size(); i++) { 14230 composeReference(t, "MedicationKnowledgeRelatedMedicationKnowledgeComponent", "reference", element.getReference().get(i), i); 14231 } 14232 } 14233 14234 protected void composeMedicationKnowledgeMonographComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMonographComponent 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, "monograph", name, element, index); 14244 if (element.hasType()) { 14245 composeCodeableConcept(t, "MedicationKnowledgeMonographComponent", "type", element.getType(), -1); 14246 } 14247 if (element.hasSource()) { 14248 composeReference(t, "MedicationKnowledgeMonographComponent", "source", element.getSource(), -1); 14249 } 14250 } 14251 14252 protected void composeMedicationKnowledgeIngredientComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeIngredientComponent element, int index) { 14253 if (element == null) 14254 return; 14255 Complex t; 14256 if (Utilities.noString(parentType)) 14257 t = parent; 14258 else { 14259 t = parent.predicate("fhir:"+parentType+'.'+name); 14260 } 14261 composeBackboneElement(t, "ingredient", name, element, index); 14262 if (element.hasItem()) { 14263 composeType(t, "MedicationKnowledgeIngredientComponent", "item", element.getItem(), -1); 14264 } 14265 if (element.hasIsActiveElement()) { 14266 composeBoolean(t, "MedicationKnowledgeIngredientComponent", "isActive", element.getIsActiveElement(), -1); 14267 } 14268 if (element.hasStrength()) { 14269 composeType(t, "MedicationKnowledgeIngredientComponent", "strength", element.getStrength(), -1); 14270 } 14271 } 14272 14273 protected void composeMedicationKnowledgeCostComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeCostComponent element, int index) { 14274 if (element == null) 14275 return; 14276 Complex t; 14277 if (Utilities.noString(parentType)) 14278 t = parent; 14279 else { 14280 t = parent.predicate("fhir:"+parentType+'.'+name); 14281 } 14282 composeBackboneElement(t, "cost", name, element, index); 14283 if (element.hasType()) { 14284 composeCodeableConcept(t, "MedicationKnowledgeCostComponent", "type", element.getType(), -1); 14285 } 14286 if (element.hasSourceElement()) { 14287 composeString(t, "MedicationKnowledgeCostComponent", "source", element.getSourceElement(), -1); 14288 } 14289 if (element.hasCost()) { 14290 composeMoney(t, "MedicationKnowledgeCostComponent", "cost", element.getCost(), -1); 14291 } 14292 } 14293 14294 protected void composeMedicationKnowledgeMonitoringProgramComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMonitoringProgramComponent element, int index) { 14295 if (element == null) 14296 return; 14297 Complex t; 14298 if (Utilities.noString(parentType)) 14299 t = parent; 14300 else { 14301 t = parent.predicate("fhir:"+parentType+'.'+name); 14302 } 14303 composeBackboneElement(t, "monitoringProgram", name, element, index); 14304 if (element.hasType()) { 14305 composeCodeableConcept(t, "MedicationKnowledgeMonitoringProgramComponent", "type", element.getType(), -1); 14306 } 14307 if (element.hasNameElement()) { 14308 composeString(t, "MedicationKnowledgeMonitoringProgramComponent", "name", element.getNameElement(), -1); 14309 } 14310 } 14311 14312 protected void composeMedicationKnowledgeAdministrationGuidelineComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeAdministrationGuidelineComponent element, int index) { 14313 if (element == null) 14314 return; 14315 Complex t; 14316 if (Utilities.noString(parentType)) 14317 t = parent; 14318 else { 14319 t = parent.predicate("fhir:"+parentType+'.'+name); 14320 } 14321 composeBackboneElement(t, "administrationGuideline", name, element, index); 14322 for (int i = 0; i < element.getDosage().size(); i++) { 14323 composeMedicationKnowledgeAdministrationGuidelineDosageComponent(t, "MedicationKnowledgeAdministrationGuidelineComponent", "dosage", element.getDosage().get(i), i); 14324 } 14325 if (element.hasIndication()) { 14326 composeType(t, "MedicationKnowledgeAdministrationGuidelineComponent", "indication", element.getIndication(), -1); 14327 } 14328 for (int i = 0; i < element.getPatientCharacteristic().size(); i++) { 14329 composeMedicationKnowledgeAdministrationGuidelinePatientCharacteristicComponent(t, "MedicationKnowledgeAdministrationGuidelineComponent", "patientCharacteristic", element.getPatientCharacteristic().get(i), i); 14330 } 14331 } 14332 14333 protected void composeMedicationKnowledgeAdministrationGuidelineDosageComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeAdministrationGuidelineDosageComponent element, int index) { 14334 if (element == null) 14335 return; 14336 Complex t; 14337 if (Utilities.noString(parentType)) 14338 t = parent; 14339 else { 14340 t = parent.predicate("fhir:"+parentType+'.'+name); 14341 } 14342 composeBackboneElement(t, "dosage", name, element, index); 14343 if (element.hasType()) { 14344 composeCodeableConcept(t, "MedicationKnowledgeAdministrationGuidelineDosageComponent", "type", element.getType(), -1); 14345 } 14346 for (int i = 0; i < element.getDosage().size(); i++) { 14347 composeDosage(t, "MedicationKnowledgeAdministrationGuidelineDosageComponent", "dosage", element.getDosage().get(i), i); 14348 } 14349 } 14350 14351 protected void composeMedicationKnowledgeAdministrationGuidelinePatientCharacteristicComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeAdministrationGuidelinePatientCharacteristicComponent element, int index) { 14352 if (element == null) 14353 return; 14354 Complex t; 14355 if (Utilities.noString(parentType)) 14356 t = parent; 14357 else { 14358 t = parent.predicate("fhir:"+parentType+'.'+name); 14359 } 14360 composeBackboneElement(t, "patientCharacteristic", name, element, index); 14361 if (element.hasCharacteristic()) { 14362 composeType(t, "MedicationKnowledgeAdministrationGuidelinePatientCharacteristicComponent", "characteristic", element.getCharacteristic(), -1); 14363 } 14364 for (int i = 0; i < element.getValue().size(); i++) { 14365 composeString(t, "MedicationKnowledgeAdministrationGuidelinePatientCharacteristicComponent", "value", element.getValue().get(i), i); 14366 } 14367 } 14368 14369 protected void composeMedicationKnowledgeMedicineClassificationComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeMedicineClassificationComponent element, int index) { 14370 if (element == null) 14371 return; 14372 Complex t; 14373 if (Utilities.noString(parentType)) 14374 t = parent; 14375 else { 14376 t = parent.predicate("fhir:"+parentType+'.'+name); 14377 } 14378 composeBackboneElement(t, "medicineClassification", name, element, index); 14379 if (element.hasType()) { 14380 composeCodeableConcept(t, "MedicationKnowledgeMedicineClassificationComponent", "type", element.getType(), -1); 14381 } 14382 for (int i = 0; i < element.getClassification().size(); i++) { 14383 composeCodeableConcept(t, "MedicationKnowledgeMedicineClassificationComponent", "classification", element.getClassification().get(i), i); 14384 } 14385 } 14386 14387 protected void composeMedicationKnowledgePackagingComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgePackagingComponent element, int index) { 14388 if (element == null) 14389 return; 14390 Complex t; 14391 if (Utilities.noString(parentType)) 14392 t = parent; 14393 else { 14394 t = parent.predicate("fhir:"+parentType+'.'+name); 14395 } 14396 composeBackboneElement(t, "packaging", name, element, index); 14397 if (element.hasType()) { 14398 composeCodeableConcept(t, "MedicationKnowledgePackagingComponent", "type", element.getType(), -1); 14399 } 14400 if (element.hasQuantity()) { 14401 composeQuantity(t, "MedicationKnowledgePackagingComponent", "quantity", element.getQuantity(), -1); 14402 } 14403 if (element.hasDevice()) { 14404 composeReference(t, "MedicationKnowledgePackagingComponent", "device", element.getDevice(), -1); 14405 } 14406 if (element.hasMaterial()) { 14407 composeCodeableConcept(t, "MedicationKnowledgePackagingComponent", "material", element.getMaterial(), -1); 14408 } 14409 for (int i = 0; i < element.getPackaging().size(); i++) { 14410 composeMedicationKnowledgePackagingComponent(t, "MedicationKnowledgePackagingComponent", "packaging", element.getPackaging().get(i), i); 14411 } 14412 } 14413 14414 protected void composeMedicationKnowledgeDrugCharacteristicComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeDrugCharacteristicComponent 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, "drugCharacteristic", name, element, index); 14424 if (element.hasType()) { 14425 composeCodeableConcept(t, "MedicationKnowledgeDrugCharacteristicComponent", "type", element.getType(), -1); 14426 } 14427 if (element.hasValue()) { 14428 composeType(t, "MedicationKnowledgeDrugCharacteristicComponent", "value", element.getValue(), -1); 14429 } 14430 } 14431 14432 protected void composeMedicationKnowledgeRegulatoryComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatoryComponent 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 composeBackboneElement(t, "regulatory", name, element, index); 14442 if (element.hasRegulatoryAuthority()) { 14443 composeReference(t, "MedicationKnowledgeRegulatoryComponent", "regulatoryAuthority", element.getRegulatoryAuthority(), -1); 14444 } 14445 for (int i = 0; i < element.getSubstitution().size(); i++) { 14446 composeMedicationKnowledgeRegulatorySubstitutionComponent(t, "MedicationKnowledgeRegulatoryComponent", "substitution", element.getSubstitution().get(i), i); 14447 } 14448 for (int i = 0; i < element.getSchedule().size(); i++) { 14449 composeCodeableConcept(t, "MedicationKnowledgeRegulatoryComponent", "schedule", element.getSchedule().get(i), i); 14450 } 14451 if (element.hasMaxDispense()) { 14452 composeMedicationKnowledgeRegulatoryMaxDispenseComponent(t, "MedicationKnowledgeRegulatoryComponent", "maxDispense", element.getMaxDispense(), -1); 14453 } 14454 } 14455 14456 protected void composeMedicationKnowledgeRegulatorySubstitutionComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatorySubstitutionComponent element, int index) { 14457 if (element == null) 14458 return; 14459 Complex t; 14460 if (Utilities.noString(parentType)) 14461 t = parent; 14462 else { 14463 t = parent.predicate("fhir:"+parentType+'.'+name); 14464 } 14465 composeBackboneElement(t, "substitution", name, element, index); 14466 if (element.hasType()) { 14467 composeCodeableConcept(t, "MedicationKnowledgeRegulatorySubstitutionComponent", "type", element.getType(), -1); 14468 } 14469 if (element.hasAllowedElement()) { 14470 composeBoolean(t, "MedicationKnowledgeRegulatorySubstitutionComponent", "allowed", element.getAllowedElement(), -1); 14471 } 14472 } 14473 14474 protected void composeMedicationKnowledgeRegulatoryMaxDispenseComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeRegulatoryMaxDispenseComponent element, int index) { 14475 if (element == null) 14476 return; 14477 Complex t; 14478 if (Utilities.noString(parentType)) 14479 t = parent; 14480 else { 14481 t = parent.predicate("fhir:"+parentType+'.'+name); 14482 } 14483 composeBackboneElement(t, "maxDispense", name, element, index); 14484 if (element.hasQuantity()) { 14485 composeQuantity(t, "MedicationKnowledgeRegulatoryMaxDispenseComponent", "quantity", element.getQuantity(), -1); 14486 } 14487 if (element.hasPeriod()) { 14488 composeDuration(t, "MedicationKnowledgeRegulatoryMaxDispenseComponent", "period", element.getPeriod(), -1); 14489 } 14490 } 14491 14492 protected void composeMedicationKnowledgeKineticCharacteristicComponent(Complex parent, String parentType, String name, MedicationKnowledge.MedicationKnowledgeKineticCharacteristicComponent element, int index) { 14493 if (element == null) 14494 return; 14495 Complex t; 14496 if (Utilities.noString(parentType)) 14497 t = parent; 14498 else { 14499 t = parent.predicate("fhir:"+parentType+'.'+name); 14500 } 14501 composeBackboneElement(t, "kineticCharacteristic", name, element, index); 14502 if (element.hasType()) { 14503 composeCodeableConcept(t, "MedicationKnowledgeKineticCharacteristicComponent", "type", element.getType(), -1); 14504 } 14505 if (element.hasValue()) { 14506 composeType(t, "MedicationKnowledgeKineticCharacteristicComponent", "value", element.getValue(), -1); 14507 } 14508 } 14509 14510 protected void composeMedicationRequest(Complex parent, String parentType, String name, MedicationRequest element, int index) { 14511 if (element == null) 14512 return; 14513 Complex t; 14514 if (Utilities.noString(parentType)) 14515 t = parent; 14516 else { 14517 t = parent.predicate("fhir:"+parentType+'.'+name); 14518 } 14519 composeDomainResource(t, "MedicationRequest", name, element, index); 14520 for (int i = 0; i < element.getIdentifier().size(); i++) { 14521 composeIdentifier(t, "MedicationRequest", "identifier", element.getIdentifier().get(i), i); 14522 } 14523 if (element.hasStatusElement()) { 14524 composeEnum(t, "MedicationRequest", "status", element.getStatusElement(), -1); 14525 } 14526 if (element.hasStatusReason()) { 14527 composeCodeableConcept(t, "MedicationRequest", "statusReason", element.getStatusReason(), -1); 14528 } 14529 if (element.hasIntentElement()) { 14530 composeEnum(t, "MedicationRequest", "intent", element.getIntentElement(), -1); 14531 } 14532 for (int i = 0; i < element.getCategory().size(); i++) { 14533 composeCodeableConcept(t, "MedicationRequest", "category", element.getCategory().get(i), i); 14534 } 14535 if (element.hasPriorityElement()) { 14536 composeEnum(t, "MedicationRequest", "priority", element.getPriorityElement(), -1); 14537 } 14538 if (element.hasDoNotPerformElement()) { 14539 composeBoolean(t, "MedicationRequest", "doNotPerform", element.getDoNotPerformElement(), -1); 14540 } 14541 if (element.hasReportedElement()) { 14542 composeBoolean(t, "MedicationRequest", "reported", element.getReportedElement(), -1); 14543 } 14544 if (element.hasInformationSource()) { 14545 composeReference(t, "MedicationRequest", "informationSource", element.getInformationSource(), -1); 14546 } 14547 if (element.hasMedication()) { 14548 composeType(t, "MedicationRequest", "medication", element.getMedication(), -1); 14549 } 14550 if (element.hasSubject()) { 14551 composeReference(t, "MedicationRequest", "subject", element.getSubject(), -1); 14552 } 14553 if (element.hasEncounter()) { 14554 composeReference(t, "MedicationRequest", "encounter", element.getEncounter(), -1); 14555 } 14556 for (int i = 0; i < element.getSupportingInformation().size(); i++) { 14557 composeReference(t, "MedicationRequest", "supportingInformation", element.getSupportingInformation().get(i), i); 14558 } 14559 if (element.hasAuthoredOnElement()) { 14560 composeDateTime(t, "MedicationRequest", "authoredOn", element.getAuthoredOnElement(), -1); 14561 } 14562 if (element.hasRequester()) { 14563 composeReference(t, "MedicationRequest", "requester", element.getRequester(), -1); 14564 } 14565 if (element.hasPerformer()) { 14566 composeReference(t, "MedicationRequest", "performer", element.getPerformer(), -1); 14567 } 14568 if (element.hasPerformerType()) { 14569 composeCodeableConcept(t, "MedicationRequest", "performerType", element.getPerformerType(), -1); 14570 } 14571 if (element.hasRecorder()) { 14572 composeReference(t, "MedicationRequest", "recorder", element.getRecorder(), -1); 14573 } 14574 for (int i = 0; i < element.getReason().size(); i++) { 14575 composeCodeableReference(t, "MedicationRequest", "reason", element.getReason().get(i), i); 14576 } 14577 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) { 14578 composeCanonical(t, "MedicationRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 14579 } 14580 for (int i = 0; i < element.getInstantiatesUri().size(); i++) { 14581 composeUri(t, "MedicationRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i); 14582 } 14583 for (int i = 0; i < element.getBasedOn().size(); i++) { 14584 composeReference(t, "MedicationRequest", "basedOn", element.getBasedOn().get(i), i); 14585 } 14586 if (element.hasGroupIdentifier()) { 14587 composeIdentifier(t, "MedicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 14588 } 14589 if (element.hasCourseOfTherapyType()) { 14590 composeCodeableConcept(t, "MedicationRequest", "courseOfTherapyType", element.getCourseOfTherapyType(), -1); 14591 } 14592 for (int i = 0; i < element.getInsurance().size(); i++) { 14593 composeReference(t, "MedicationRequest", "insurance", element.getInsurance().get(i), i); 14594 } 14595 for (int i = 0; i < element.getNote().size(); i++) { 14596 composeAnnotation(t, "MedicationRequest", "note", element.getNote().get(i), i); 14597 } 14598 if (element.hasRenderedDosageInstructionElement()) { 14599 composeString(t, "MedicationRequest", "renderedDosageInstruction", element.getRenderedDosageInstructionElement(), -1); 14600 } 14601 for (int i = 0; i < element.getDosageInstruction().size(); i++) { 14602 composeDosage(t, "MedicationRequest", "dosageInstruction", element.getDosageInstruction().get(i), i); 14603 } 14604 if (element.hasDispenseRequest()) { 14605 composeMedicationRequestDispenseRequestComponent(t, "MedicationRequest", "dispenseRequest", element.getDispenseRequest(), -1); 14606 } 14607 if (element.hasSubstitution()) { 14608 composeMedicationRequestSubstitutionComponent(t, "MedicationRequest", "substitution", element.getSubstitution(), -1); 14609 } 14610 if (element.hasPriorPrescription()) { 14611 composeReference(t, "MedicationRequest", "priorPrescription", element.getPriorPrescription(), -1); 14612 } 14613 for (int i = 0; i < element.getDetectedIssue().size(); i++) { 14614 composeReference(t, "MedicationRequest", "detectedIssue", element.getDetectedIssue().get(i), i); 14615 } 14616 for (int i = 0; i < element.getEventHistory().size(); i++) { 14617 composeReference(t, "MedicationRequest", "eventHistory", element.getEventHistory().get(i), i); 14618 } 14619 } 14620 14621 protected void composeMedicationRequestDispenseRequestComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestDispenseRequestComponent element, int index) { 14622 if (element == null) 14623 return; 14624 Complex t; 14625 if (Utilities.noString(parentType)) 14626 t = parent; 14627 else { 14628 t = parent.predicate("fhir:"+parentType+'.'+name); 14629 } 14630 composeBackboneElement(t, "dispenseRequest", name, element, index); 14631 if (element.hasInitialFill()) { 14632 composeMedicationRequestDispenseRequestInitialFillComponent(t, "MedicationRequestDispenseRequestComponent", "initialFill", element.getInitialFill(), -1); 14633 } 14634 if (element.hasDispenseInterval()) { 14635 composeDuration(t, "MedicationRequestDispenseRequestComponent", "dispenseInterval", element.getDispenseInterval(), -1); 14636 } 14637 if (element.hasValidityPeriod()) { 14638 composePeriod(t, "MedicationRequestDispenseRequestComponent", "validityPeriod", element.getValidityPeriod(), -1); 14639 } 14640 if (element.hasNumberOfRepeatsAllowedElement()) { 14641 composeUnsignedInt(t, "MedicationRequestDispenseRequestComponent", "numberOfRepeatsAllowed", element.getNumberOfRepeatsAllowedElement(), -1); 14642 } 14643 if (element.hasQuantity()) { 14644 composeQuantity(t, "MedicationRequestDispenseRequestComponent", "quantity", element.getQuantity(), -1); 14645 } 14646 if (element.hasExpectedSupplyDuration()) { 14647 composeDuration(t, "MedicationRequestDispenseRequestComponent", "expectedSupplyDuration", element.getExpectedSupplyDuration(), -1); 14648 } 14649 if (element.hasDispenser()) { 14650 composeReference(t, "MedicationRequestDispenseRequestComponent", "dispenser", element.getDispenser(), -1); 14651 } 14652 } 14653 14654 protected void composeMedicationRequestDispenseRequestInitialFillComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestDispenseRequestInitialFillComponent element, int index) { 14655 if (element == null) 14656 return; 14657 Complex t; 14658 if (Utilities.noString(parentType)) 14659 t = parent; 14660 else { 14661 t = parent.predicate("fhir:"+parentType+'.'+name); 14662 } 14663 composeBackboneElement(t, "initialFill", name, element, index); 14664 if (element.hasQuantity()) { 14665 composeQuantity(t, "MedicationRequestDispenseRequestInitialFillComponent", "quantity", element.getQuantity(), -1); 14666 } 14667 if (element.hasDuration()) { 14668 composeDuration(t, "MedicationRequestDispenseRequestInitialFillComponent", "duration", element.getDuration(), -1); 14669 } 14670 } 14671 14672 protected void composeMedicationRequestSubstitutionComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestSubstitutionComponent element, int index) { 14673 if (element == null) 14674 return; 14675 Complex t; 14676 if (Utilities.noString(parentType)) 14677 t = parent; 14678 else { 14679 t = parent.predicate("fhir:"+parentType+'.'+name); 14680 } 14681 composeBackboneElement(t, "substitution", name, element, index); 14682 if (element.hasAllowed()) { 14683 composeType(t, "MedicationRequestSubstitutionComponent", "allowed", element.getAllowed(), -1); 14684 } 14685 if (element.hasReason()) { 14686 composeCodeableConcept(t, "MedicationRequestSubstitutionComponent", "reason", element.getReason(), -1); 14687 } 14688 } 14689 14690 protected void composeMedicationUsage(Complex parent, String parentType, String name, MedicationUsage 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 composeDomainResource(t, "MedicationUsage", name, element, index); 14700 for (int i = 0; i < element.getIdentifier().size(); i++) { 14701 composeIdentifier(t, "MedicationUsage", "identifier", element.getIdentifier().get(i), i); 14702 } 14703 for (int i = 0; i < element.getBasedOn().size(); i++) { 14704 composeReference(t, "MedicationUsage", "basedOn", element.getBasedOn().get(i), i); 14705 } 14706 for (int i = 0; i < element.getPartOf().size(); i++) { 14707 composeReference(t, "MedicationUsage", "partOf", element.getPartOf().get(i), i); 14708 } 14709 if (element.hasStatusElement()) { 14710 composeEnum(t, "MedicationUsage", "status", element.getStatusElement(), -1); 14711 } 14712 for (int i = 0; i < element.getStatusReason().size(); i++) { 14713 composeCodeableConcept(t, "MedicationUsage", "statusReason", element.getStatusReason().get(i), i); 14714 } 14715 for (int i = 0; i < element.getCategory().size(); i++) { 14716 composeCodeableConcept(t, "MedicationUsage", "category", element.getCategory().get(i), i); 14717 } 14718 if (element.hasMedication()) { 14719 composeType(t, "MedicationUsage", "medication", element.getMedication(), -1); 14720 } 14721 if (element.hasSubject()) { 14722 composeReference(t, "MedicationUsage", "subject", element.getSubject(), -1); 14723 } 14724 if (element.hasEncounter()) { 14725 composeReference(t, "MedicationUsage", "encounter", element.getEncounter(), -1); 14726 } 14727 if (element.hasEffective()) { 14728 composeType(t, "MedicationUsage", "effective", element.getEffective(), -1); 14729 } 14730 if (element.hasDateAssertedElement()) { 14731 composeDateTime(t, "MedicationUsage", "dateAsserted", element.getDateAssertedElement(), -1); 14732 } 14733 if (element.hasInformationSource()) { 14734 composeReference(t, "MedicationUsage", "informationSource", element.getInformationSource(), -1); 14735 } 14736 for (int i = 0; i < element.getDerivedFrom().size(); i++) { 14737 composeReference(t, "MedicationUsage", "derivedFrom", element.getDerivedFrom().get(i), i); 14738 } 14739 for (int i = 0; i < element.getReason().size(); i++) { 14740 composeCodeableReference(t, "MedicationUsage", "reason", element.getReason().get(i), i); 14741 } 14742 for (int i = 0; i < element.getNote().size(); i++) { 14743 composeAnnotation(t, "MedicationUsage", "note", element.getNote().get(i), i); 14744 } 14745 if (element.hasRenderedDosageInstructionElement()) { 14746 composeString(t, "MedicationUsage", "renderedDosageInstruction", element.getRenderedDosageInstructionElement(), -1); 14747 } 14748 for (int i = 0; i < element.getDosage().size(); i++) { 14749 composeDosage(t, "MedicationUsage", "dosage", element.getDosage().get(i), i); 14750 } 14751 if (element.hasTakenAsOrderedElement()) { 14752 composeBoolean(t, "MedicationUsage", "takenAsOrdered", element.getTakenAsOrderedElement(), -1); 14753 } 14754 } 14755 14756 protected void composeMedicinalProductDefinition(Complex parent, String parentType, String name, MedicinalProductDefinition element, int index) { 14757 if (element == null) 14758 return; 14759 Complex t; 14760 if (Utilities.noString(parentType)) 14761 t = parent; 14762 else { 14763 t = parent.predicate("fhir:"+parentType+'.'+name); 14764 } 14765 composeDomainResource(t, "MedicinalProductDefinition", name, element, index); 14766 for (int i = 0; i < element.getIdentifier().size(); i++) { 14767 composeIdentifier(t, "MedicinalProductDefinition", "identifier", element.getIdentifier().get(i), i); 14768 } 14769 if (element.hasType()) { 14770 composeCodeableConcept(t, "MedicinalProductDefinition", "type", element.getType(), -1); 14771 } 14772 if (element.hasDomain()) { 14773 composeCoding(t, "MedicinalProductDefinition", "domain", element.getDomain(), -1); 14774 } 14775 if (element.hasVersionElement()) { 14776 composeString(t, "MedicinalProductDefinition", "version", element.getVersionElement(), -1); 14777 } 14778 if (element.hasStatus()) { 14779 composeCoding(t, "MedicinalProductDefinition", "status", element.getStatus(), -1); 14780 } 14781 if (element.hasDescriptionElement()) { 14782 composeMarkdown(t, "MedicinalProductDefinition", "description", element.getDescriptionElement(), -1); 14783 } 14784 if (element.hasCombinedPharmaceuticalDoseForm()) { 14785 composeCodeableConcept(t, "MedicinalProductDefinition", "combinedPharmaceuticalDoseForm", element.getCombinedPharmaceuticalDoseForm(), -1); 14786 } 14787 if (element.hasIndicationElement()) { 14788 composeMarkdown(t, "MedicinalProductDefinition", "indication", element.getIndicationElement(), -1); 14789 } 14790 if (element.hasLegalStatusOfSupply()) { 14791 composeCodeableConcept(t, "MedicinalProductDefinition", "legalStatusOfSupply", element.getLegalStatusOfSupply(), -1); 14792 } 14793 if (element.hasAdditionalMonitoringIndicator()) { 14794 composeCodeableConcept(t, "MedicinalProductDefinition", "additionalMonitoringIndicator", element.getAdditionalMonitoringIndicator(), -1); 14795 } 14796 for (int i = 0; i < element.getSpecialMeasures().size(); i++) { 14797 composeCodeableConcept(t, "MedicinalProductDefinition", "specialMeasures", element.getSpecialMeasures().get(i), i); 14798 } 14799 if (element.hasPaediatricUseIndicator()) { 14800 composeCodeableConcept(t, "MedicinalProductDefinition", "paediatricUseIndicator", element.getPaediatricUseIndicator(), -1); 14801 } 14802 for (int i = 0; i < element.getProductClassification().size(); i++) { 14803 composeCodeableConcept(t, "MedicinalProductDefinition", "productClassification", element.getProductClassification().get(i), i); 14804 } 14805 for (int i = 0; i < element.getMarketingStatus().size(); i++) { 14806 composeMarketingStatus(t, "MedicinalProductDefinition", "marketingStatus", element.getMarketingStatus().get(i), i); 14807 } 14808 for (int i = 0; i < element.getPharmaceuticalProduct().size(); i++) { 14809 composeReference(t, "MedicinalProductDefinition", "pharmaceuticalProduct", element.getPharmaceuticalProduct().get(i), i); 14810 } 14811 for (int i = 0; i < element.getPackagedMedicinalProduct().size(); i++) { 14812 composeReference(t, "MedicinalProductDefinition", "packagedMedicinalProduct", element.getPackagedMedicinalProduct().get(i), i); 14813 } 14814 for (int i = 0; i < element.getIngredient().size(); i++) { 14815 composeReference(t, "MedicinalProductDefinition", "ingredient", element.getIngredient().get(i), i); 14816 } 14817 for (int i = 0; i < element.getAttachedDocument().size(); i++) { 14818 composeReference(t, "MedicinalProductDefinition", "attachedDocument", element.getAttachedDocument().get(i), i); 14819 } 14820 for (int i = 0; i < element.getMasterFile().size(); i++) { 14821 composeReference(t, "MedicinalProductDefinition", "masterFile", element.getMasterFile().get(i), i); 14822 } 14823 for (int i = 0; i < element.getContact().size(); i++) { 14824 composeMedicinalProductDefinitionContactComponent(t, "MedicinalProductDefinition", "contact", element.getContact().get(i), i); 14825 } 14826 for (int i = 0; i < element.getClinicalTrial().size(); i++) { 14827 composeReference(t, "MedicinalProductDefinition", "clinicalTrial", element.getClinicalTrial().get(i), i); 14828 } 14829 for (int i = 0; i < element.getName().size(); i++) { 14830 composeMedicinalProductDefinitionNameComponent(t, "MedicinalProductDefinition", "name", element.getName().get(i), i); 14831 } 14832 for (int i = 0; i < element.getCrossReference().size(); i++) { 14833 composeMedicinalProductDefinitionCrossReferenceComponent(t, "MedicinalProductDefinition", "crossReference", element.getCrossReference().get(i), i); 14834 } 14835 for (int i = 0; i < element.getManufacturingBusinessOperation().size(); i++) { 14836 composeMedicinalProductDefinitionManufacturingBusinessOperationComponent(t, "MedicinalProductDefinition", "manufacturingBusinessOperation", element.getManufacturingBusinessOperation().get(i), i); 14837 } 14838 } 14839 14840 protected void composeMedicinalProductDefinitionContactComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionContactComponent 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, "contact", name, element, index); 14850 if (element.hasType()) { 14851 composeCodeableConcept(t, "MedicinalProductDefinitionContactComponent", "type", element.getType(), -1); 14852 } 14853 if (element.hasContact()) { 14854 composeReference(t, "MedicinalProductDefinitionContactComponent", "contact", element.getContact(), -1); 14855 } 14856 } 14857 14858 protected void composeMedicinalProductDefinitionNameComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionNameComponent element, int index) { 14859 if (element == null) 14860 return; 14861 Complex t; 14862 if (Utilities.noString(parentType)) 14863 t = parent; 14864 else { 14865 t = parent.predicate("fhir:"+parentType+'.'+name); 14866 } 14867 composeBackboneElement(t, "name", name, element, index); 14868 if (element.hasProductNameElement()) { 14869 composeString(t, "MedicinalProductDefinitionNameComponent", "productName", element.getProductNameElement(), -1); 14870 } 14871 if (element.hasType()) { 14872 composeCoding(t, "MedicinalProductDefinitionNameComponent", "type", element.getType(), -1); 14873 } 14874 for (int i = 0; i < element.getNamePart().size(); i++) { 14875 composeMedicinalProductDefinitionNameNamePartComponent(t, "MedicinalProductDefinitionNameComponent", "namePart", element.getNamePart().get(i), i); 14876 } 14877 for (int i = 0; i < element.getCountryLanguage().size(); i++) { 14878 composeMedicinalProductDefinitionNameCountryLanguageComponent(t, "MedicinalProductDefinitionNameComponent", "countryLanguage", element.getCountryLanguage().get(i), i); 14879 } 14880 } 14881 14882 protected void composeMedicinalProductDefinitionNameNamePartComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionNameNamePartComponent element, int index) { 14883 if (element == null) 14884 return; 14885 Complex t; 14886 if (Utilities.noString(parentType)) 14887 t = parent; 14888 else { 14889 t = parent.predicate("fhir:"+parentType+'.'+name); 14890 } 14891 composeBackboneElement(t, "namePart", name, element, index); 14892 if (element.hasPartElement()) { 14893 composeString(t, "MedicinalProductDefinitionNameNamePartComponent", "part", element.getPartElement(), -1); 14894 } 14895 if (element.hasType()) { 14896 composeCoding(t, "MedicinalProductDefinitionNameNamePartComponent", "type", element.getType(), -1); 14897 } 14898 } 14899 14900 protected void composeMedicinalProductDefinitionNameCountryLanguageComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionNameCountryLanguageComponent element, int index) { 14901 if (element == null) 14902 return; 14903 Complex t; 14904 if (Utilities.noString(parentType)) 14905 t = parent; 14906 else { 14907 t = parent.predicate("fhir:"+parentType+'.'+name); 14908 } 14909 composeBackboneElement(t, "countryLanguage", name, element, index); 14910 if (element.hasCountry()) { 14911 composeCodeableConcept(t, "MedicinalProductDefinitionNameCountryLanguageComponent", "country", element.getCountry(), -1); 14912 } 14913 if (element.hasJurisdiction()) { 14914 composeCodeableConcept(t, "MedicinalProductDefinitionNameCountryLanguageComponent", "jurisdiction", element.getJurisdiction(), -1); 14915 } 14916 if (element.hasLanguage()) { 14917 composeCodeableConcept(t, "MedicinalProductDefinitionNameCountryLanguageComponent", "language", element.getLanguage(), -1); 14918 } 14919 } 14920 14921 protected void composeMedicinalProductDefinitionCrossReferenceComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionCrossReferenceComponent element, int index) { 14922 if (element == null) 14923 return; 14924 Complex t; 14925 if (Utilities.noString(parentType)) 14926 t = parent; 14927 else { 14928 t = parent.predicate("fhir:"+parentType+'.'+name); 14929 } 14930 composeBackboneElement(t, "crossReference", name, element, index); 14931 if (element.hasProduct()) { 14932 composeType(t, "MedicinalProductDefinitionCrossReferenceComponent", "product", element.getProduct(), -1); 14933 } 14934 if (element.hasType()) { 14935 composeCoding(t, "MedicinalProductDefinitionCrossReferenceComponent", "type", element.getType(), -1); 14936 } 14937 } 14938 14939 protected void composeMedicinalProductDefinitionManufacturingBusinessOperationComponent(Complex parent, String parentType, String name, MedicinalProductDefinition.MedicinalProductDefinitionManufacturingBusinessOperationComponent element, int index) { 14940 if (element == null) 14941 return; 14942 Complex t; 14943 if (Utilities.noString(parentType)) 14944 t = parent; 14945 else { 14946 t = parent.predicate("fhir:"+parentType+'.'+name); 14947 } 14948 composeBackboneElement(t, "manufacturingBusinessOperation", name, element, index); 14949 if (element.hasType()) { 14950 composeType(t, "MedicinalProductDefinitionManufacturingBusinessOperationComponent", "type", element.getType(), -1); 14951 } 14952 if (element.hasEffectiveDate()) { 14953 composePeriod(t, "MedicinalProductDefinitionManufacturingBusinessOperationComponent", "effectiveDate", element.getEffectiveDate(), -1); 14954 } 14955 for (int i = 0; i < element.getManufacturer().size(); i++) { 14956 composeReference(t, "MedicinalProductDefinitionManufacturingBusinessOperationComponent", "manufacturer", element.getManufacturer().get(i), i); 14957 } 14958 if (element.hasAuthorization()) { 14959 composeReference(t, "MedicinalProductDefinitionManufacturingBusinessOperationComponent", "authorization", element.getAuthorization(), -1); 14960 } 14961 if (element.hasConfidentialityIndicator()) { 14962 composeCodeableConcept(t, "MedicinalProductDefinitionManufacturingBusinessOperationComponent", "confidentialityIndicator", element.getConfidentialityIndicator(), -1); 14963 } 14964 } 14965 14966 protected void composeMessageDefinition(Complex parent, String parentType, String name, MessageDefinition element, int index) { 14967 if (element == null) 14968 return; 14969 Complex t; 14970 if (Utilities.noString(parentType)) 14971 t = parent; 14972 else { 14973 t = parent.predicate("fhir:"+parentType+'.'+name); 14974 } 14975 composeCanonicalResource(t, "MessageDefinition", name, element, index); 14976 if (element.hasUrlElement()) { 14977 composeUri(t, "MessageDefinition", "url", element.getUrlElement(), -1); 14978 } 14979 for (int i = 0; i < element.getIdentifier().size(); i++) { 14980 composeIdentifier(t, "MessageDefinition", "identifier", element.getIdentifier().get(i), i); 14981 } 14982 if (element.hasVersionElement()) { 14983 composeString(t, "MessageDefinition", "version", element.getVersionElement(), -1); 14984 } 14985 if (element.hasNameElement()) { 14986 composeString(t, "MessageDefinition", "name", element.getNameElement(), -1); 14987 } 14988 if (element.hasTitleElement()) { 14989 composeString(t, "MessageDefinition", "title", element.getTitleElement(), -1); 14990 } 14991 for (int i = 0; i < element.getReplaces().size(); i++) { 14992 composeCanonical(t, "MessageDefinition", "replaces", element.getReplaces().get(i), i); 14993 } 14994 if (element.hasStatusElement()) { 14995 composeEnum(t, "MessageDefinition", "status", element.getStatusElement(), -1); 14996 } 14997 if (element.hasExperimentalElement()) { 14998 composeBoolean(t, "MessageDefinition", "experimental", element.getExperimentalElement(), -1); 14999 } 15000 if (element.hasDateElement()) { 15001 composeDateTime(t, "MessageDefinition", "date", element.getDateElement(), -1); 15002 } 15003 if (element.hasPublisherElement()) { 15004 composeString(t, "MessageDefinition", "publisher", element.getPublisherElement(), -1); 15005 } 15006 for (int i = 0; i < element.getContact().size(); i++) { 15007 composeContactDetail(t, "MessageDefinition", "contact", element.getContact().get(i), i); 15008 } 15009 if (element.hasDescriptionElement()) { 15010 composeMarkdown(t, "MessageDefinition", "description", element.getDescriptionElement(), -1); 15011 } 15012 for (int i = 0; i < element.getUseContext().size(); i++) { 15013 composeUsageContext(t, "MessageDefinition", "useContext", element.getUseContext().get(i), i); 15014 } 15015 for (int i = 0; i < element.getJurisdiction().size(); i++) { 15016 composeCodeableConcept(t, "MessageDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 15017 } 15018 if (element.hasPurposeElement()) { 15019 composeMarkdown(t, "MessageDefinition", "purpose", element.getPurposeElement(), -1); 15020 } 15021 if (element.hasCopyrightElement()) { 15022 composeMarkdown(t, "MessageDefinition", "copyright", element.getCopyrightElement(), -1); 15023 } 15024 if (element.hasBaseElement()) { 15025 composeCanonical(t, "MessageDefinition", "base", element.getBaseElement(), -1); 15026 } 15027 for (int i = 0; i < element.getParent().size(); i++) { 15028 composeCanonical(t, "MessageDefinition", "parent", element.getParent().get(i), i); 15029 } 15030 if (element.hasEvent()) { 15031 composeType(t, "MessageDefinition", "event", element.getEvent(), -1); 15032 } 15033 if (element.hasCategoryElement()) { 15034 composeEnum(t, "MessageDefinition", "category", element.getCategoryElement(), -1); 15035 } 15036 for (int i = 0; i < element.getFocus().size(); i++) { 15037 composeMessageDefinitionFocusComponent(t, "MessageDefinition", "focus", element.getFocus().get(i), i); 15038 } 15039 if (element.hasResponseRequiredElement()) { 15040 composeEnum(t, "MessageDefinition", "responseRequired", element.getResponseRequiredElement(), -1); 15041 } 15042 for (int i = 0; i < element.getAllowedResponse().size(); i++) { 15043 composeMessageDefinitionAllowedResponseComponent(t, "MessageDefinition", "allowedResponse", element.getAllowedResponse().get(i), i); 15044 } 15045 for (int i = 0; i < element.getGraph().size(); i++) { 15046 composeCanonical(t, "MessageDefinition", "graph", element.getGraph().get(i), i); 15047 } 15048 } 15049 15050 protected void composeMessageDefinitionFocusComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionFocusComponent element, int index) { 15051 if (element == null) 15052 return; 15053 Complex t; 15054 if (Utilities.noString(parentType)) 15055 t = parent; 15056 else { 15057 t = parent.predicate("fhir:"+parentType+'.'+name); 15058 } 15059 composeBackboneElement(t, "focus", name, element, index); 15060 if (element.hasCodeElement()) { 15061 composeCode(t, "MessageDefinitionFocusComponent", "code", element.getCodeElement(), -1); 15062 } 15063 if (element.hasProfileElement()) { 15064 composeCanonical(t, "MessageDefinitionFocusComponent", "profile", element.getProfileElement(), -1); 15065 } 15066 if (element.hasMinElement()) { 15067 composeUnsignedInt(t, "MessageDefinitionFocusComponent", "min", element.getMinElement(), -1); 15068 } 15069 if (element.hasMaxElement()) { 15070 composeString(t, "MessageDefinitionFocusComponent", "max", element.getMaxElement(), -1); 15071 } 15072 } 15073 15074 protected void composeMessageDefinitionAllowedResponseComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionAllowedResponseComponent element, int index) { 15075 if (element == null) 15076 return; 15077 Complex t; 15078 if (Utilities.noString(parentType)) 15079 t = parent; 15080 else { 15081 t = parent.predicate("fhir:"+parentType+'.'+name); 15082 } 15083 composeBackboneElement(t, "allowedResponse", name, element, index); 15084 if (element.hasMessageElement()) { 15085 composeCanonical(t, "MessageDefinitionAllowedResponseComponent", "message", element.getMessageElement(), -1); 15086 } 15087 if (element.hasSituationElement()) { 15088 composeMarkdown(t, "MessageDefinitionAllowedResponseComponent", "situation", element.getSituationElement(), -1); 15089 } 15090 } 15091 15092 protected void composeMessageHeader(Complex parent, String parentType, String name, MessageHeader element, int index) { 15093 if (element == null) 15094 return; 15095 Complex t; 15096 if (Utilities.noString(parentType)) 15097 t = parent; 15098 else { 15099 t = parent.predicate("fhir:"+parentType+'.'+name); 15100 } 15101 composeDomainResource(t, "MessageHeader", name, element, index); 15102 if (element.hasEvent()) { 15103 composeType(t, "MessageHeader", "event", element.getEvent(), -1); 15104 } 15105 for (int i = 0; i < element.getDestination().size(); i++) { 15106 composeMessageHeaderMessageDestinationComponent(t, "MessageHeader", "destination", element.getDestination().get(i), i); 15107 } 15108 if (element.hasSender()) { 15109 composeReference(t, "MessageHeader", "sender", element.getSender(), -1); 15110 } 15111 if (element.hasEnterer()) { 15112 composeReference(t, "MessageHeader", "enterer", element.getEnterer(), -1); 15113 } 15114 if (element.hasAuthor()) { 15115 composeReference(t, "MessageHeader", "author", element.getAuthor(), -1); 15116 } 15117 if (element.hasSource()) { 15118 composeMessageHeaderMessageSourceComponent(t, "MessageHeader", "source", element.getSource(), -1); 15119 } 15120 if (element.hasResponsible()) { 15121 composeReference(t, "MessageHeader", "responsible", element.getResponsible(), -1); 15122 } 15123 if (element.hasReason()) { 15124 composeCodeableConcept(t, "MessageHeader", "reason", element.getReason(), -1); 15125 } 15126 if (element.hasResponse()) { 15127 composeMessageHeaderResponseComponent(t, "MessageHeader", "response", element.getResponse(), -1); 15128 } 15129 for (int i = 0; i < element.getFocus().size(); i++) { 15130 composeReference(t, "MessageHeader", "focus", element.getFocus().get(i), i); 15131 } 15132 if (element.hasDefinitionElement()) { 15133 composeCanonical(t, "MessageHeader", "definition", element.getDefinitionElement(), -1); 15134 } 15135 } 15136 15137 protected void composeMessageHeaderMessageDestinationComponent(Complex parent, String parentType, String name, MessageHeader.MessageDestinationComponent element, int index) { 15138 if (element == null) 15139 return; 15140 Complex t; 15141 if (Utilities.noString(parentType)) 15142 t = parent; 15143 else { 15144 t = parent.predicate("fhir:"+parentType+'.'+name); 15145 } 15146 composeBackboneElement(t, "destination", name, element, index); 15147 if (element.hasNameElement()) { 15148 composeString(t, "MessageDestinationComponent", "name", element.getNameElement(), -1); 15149 } 15150 if (element.hasTarget()) { 15151 composeReference(t, "MessageDestinationComponent", "target", element.getTarget(), -1); 15152 } 15153 if (element.hasEndpointElement()) { 15154 composeUrl(t, "MessageDestinationComponent", "endpoint", element.getEndpointElement(), -1); 15155 } 15156 if (element.hasReceiver()) { 15157 composeReference(t, "MessageDestinationComponent", "receiver", element.getReceiver(), -1); 15158 } 15159 } 15160 15161 protected void composeMessageHeaderMessageSourceComponent(Complex parent, String parentType, String name, MessageHeader.MessageSourceComponent element, int index) { 15162 if (element == null) 15163 return; 15164 Complex t; 15165 if (Utilities.noString(parentType)) 15166 t = parent; 15167 else { 15168 t = parent.predicate("fhir:"+parentType+'.'+name); 15169 } 15170 composeBackboneElement(t, "source", name, element, index); 15171 if (element.hasNameElement()) { 15172 composeString(t, "MessageSourceComponent", "name", element.getNameElement(), -1); 15173 } 15174 if (element.hasSoftwareElement()) { 15175 composeString(t, "MessageSourceComponent", "software", element.getSoftwareElement(), -1); 15176 } 15177 if (element.hasVersionElement()) { 15178 composeString(t, "MessageSourceComponent", "version", element.getVersionElement(), -1); 15179 } 15180 if (element.hasContact()) { 15181 composeContactPoint(t, "MessageSourceComponent", "contact", element.getContact(), -1); 15182 } 15183 if (element.hasEndpointElement()) { 15184 composeUrl(t, "MessageSourceComponent", "endpoint", element.getEndpointElement(), -1); 15185 } 15186 } 15187 15188 protected void composeMessageHeaderResponseComponent(Complex parent, String parentType, String name, MessageHeader.MessageHeaderResponseComponent element, int index) { 15189 if (element == null) 15190 return; 15191 Complex t; 15192 if (Utilities.noString(parentType)) 15193 t = parent; 15194 else { 15195 t = parent.predicate("fhir:"+parentType+'.'+name); 15196 } 15197 composeBackboneElement(t, "response", name, element, index); 15198 if (element.hasIdentifierElement()) { 15199 composeId(t, "MessageHeaderResponseComponent", "identifier", element.getIdentifierElement(), -1); 15200 } 15201 if (element.hasCodeElement()) { 15202 composeEnum(t, "MessageHeaderResponseComponent", "code", element.getCodeElement(), -1); 15203 } 15204 if (element.hasDetails()) { 15205 composeReference(t, "MessageHeaderResponseComponent", "details", element.getDetails(), -1); 15206 } 15207 } 15208 15209 protected void composeMolecularSequence(Complex parent, String parentType, String name, MolecularSequence element, int index) { 15210 if (element == null) 15211 return; 15212 Complex t; 15213 if (Utilities.noString(parentType)) 15214 t = parent; 15215 else { 15216 t = parent.predicate("fhir:"+parentType+'.'+name); 15217 } 15218 composeDomainResource(t, "MolecularSequence", name, element, index); 15219 for (int i = 0; i < element.getIdentifier().size(); i++) { 15220 composeIdentifier(t, "MolecularSequence", "identifier", element.getIdentifier().get(i), i); 15221 } 15222 if (element.hasTypeElement()) { 15223 composeEnum(t, "MolecularSequence", "type", element.getTypeElement(), -1); 15224 } 15225 if (element.hasCoordinateSystemElement()) { 15226 composeInteger(t, "MolecularSequence", "coordinateSystem", element.getCoordinateSystemElement(), -1); 15227 } 15228 if (element.hasPatient()) { 15229 composeReference(t, "MolecularSequence", "patient", element.getPatient(), -1); 15230 } 15231 if (element.hasSpecimen()) { 15232 composeReference(t, "MolecularSequence", "specimen", element.getSpecimen(), -1); 15233 } 15234 if (element.hasDevice()) { 15235 composeReference(t, "MolecularSequence", "device", element.getDevice(), -1); 15236 } 15237 if (element.hasPerformer()) { 15238 composeReference(t, "MolecularSequence", "performer", element.getPerformer(), -1); 15239 } 15240 if (element.hasQuantity()) { 15241 composeQuantity(t, "MolecularSequence", "quantity", element.getQuantity(), -1); 15242 } 15243 if (element.hasReferenceSeq()) { 15244 composeMolecularSequenceReferenceSeqComponent(t, "MolecularSequence", "referenceSeq", element.getReferenceSeq(), -1); 15245 } 15246 for (int i = 0; i < element.getVariant().size(); i++) { 15247 composeMolecularSequenceVariantComponent(t, "MolecularSequence", "variant", element.getVariant().get(i), i); 15248 } 15249 if (element.hasObservedSeqElement()) { 15250 composeString(t, "MolecularSequence", "observedSeq", element.getObservedSeqElement(), -1); 15251 } 15252 for (int i = 0; i < element.getQuality().size(); i++) { 15253 composeMolecularSequenceQualityComponent(t, "MolecularSequence", "quality", element.getQuality().get(i), i); 15254 } 15255 if (element.hasReadCoverageElement()) { 15256 composeInteger(t, "MolecularSequence", "readCoverage", element.getReadCoverageElement(), -1); 15257 } 15258 for (int i = 0; i < element.getRepository().size(); i++) { 15259 composeMolecularSequenceRepositoryComponent(t, "MolecularSequence", "repository", element.getRepository().get(i), i); 15260 } 15261 for (int i = 0; i < element.getPointer().size(); i++) { 15262 composeReference(t, "MolecularSequence", "pointer", element.getPointer().get(i), i); 15263 } 15264 for (int i = 0; i < element.getStructureVariant().size(); i++) { 15265 composeMolecularSequenceStructureVariantComponent(t, "MolecularSequence", "structureVariant", element.getStructureVariant().get(i), i); 15266 } 15267 } 15268 15269 protected void composeMolecularSequenceReferenceSeqComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceReferenceSeqComponent element, int index) { 15270 if (element == null) 15271 return; 15272 Complex t; 15273 if (Utilities.noString(parentType)) 15274 t = parent; 15275 else { 15276 t = parent.predicate("fhir:"+parentType+'.'+name); 15277 } 15278 composeBackboneElement(t, "referenceSeq", name, element, index); 15279 if (element.hasChromosome()) { 15280 composeCodeableConcept(t, "MolecularSequenceReferenceSeqComponent", "chromosome", element.getChromosome(), -1); 15281 } 15282 if (element.hasGenomeBuildElement()) { 15283 composeString(t, "MolecularSequenceReferenceSeqComponent", "genomeBuild", element.getGenomeBuildElement(), -1); 15284 } 15285 if (element.hasOrientationElement()) { 15286 composeEnum(t, "MolecularSequenceReferenceSeqComponent", "orientation", element.getOrientationElement(), -1); 15287 } 15288 if (element.hasReferenceSeqId()) { 15289 composeCodeableConcept(t, "MolecularSequenceReferenceSeqComponent", "referenceSeqId", element.getReferenceSeqId(), -1); 15290 } 15291 if (element.hasReferenceSeqPointer()) { 15292 composeReference(t, "MolecularSequenceReferenceSeqComponent", "referenceSeqPointer", element.getReferenceSeqPointer(), -1); 15293 } 15294 if (element.hasReferenceSeqStringElement()) { 15295 composeString(t, "MolecularSequenceReferenceSeqComponent", "referenceSeqString", element.getReferenceSeqStringElement(), -1); 15296 } 15297 if (element.hasStrandElement()) { 15298 composeEnum(t, "MolecularSequenceReferenceSeqComponent", "strand", element.getStrandElement(), -1); 15299 } 15300 if (element.hasWindowStartElement()) { 15301 composeInteger(t, "MolecularSequenceReferenceSeqComponent", "windowStart", element.getWindowStartElement(), -1); 15302 } 15303 if (element.hasWindowEndElement()) { 15304 composeInteger(t, "MolecularSequenceReferenceSeqComponent", "windowEnd", element.getWindowEndElement(), -1); 15305 } 15306 } 15307 15308 protected void composeMolecularSequenceVariantComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceVariantComponent element, int index) { 15309 if (element == null) 15310 return; 15311 Complex t; 15312 if (Utilities.noString(parentType)) 15313 t = parent; 15314 else { 15315 t = parent.predicate("fhir:"+parentType+'.'+name); 15316 } 15317 composeBackboneElement(t, "variant", name, element, index); 15318 if (element.hasStartElement()) { 15319 composeInteger(t, "MolecularSequenceVariantComponent", "start", element.getStartElement(), -1); 15320 } 15321 if (element.hasEndElement()) { 15322 composeInteger(t, "MolecularSequenceVariantComponent", "end", element.getEndElement(), -1); 15323 } 15324 if (element.hasObservedAlleleElement()) { 15325 composeString(t, "MolecularSequenceVariantComponent", "observedAllele", element.getObservedAlleleElement(), -1); 15326 } 15327 if (element.hasReferenceAlleleElement()) { 15328 composeString(t, "MolecularSequenceVariantComponent", "referenceAllele", element.getReferenceAlleleElement(), -1); 15329 } 15330 if (element.hasCigarElement()) { 15331 composeString(t, "MolecularSequenceVariantComponent", "cigar", element.getCigarElement(), -1); 15332 } 15333 if (element.hasVariantPointer()) { 15334 composeReference(t, "MolecularSequenceVariantComponent", "variantPointer", element.getVariantPointer(), -1); 15335 } 15336 } 15337 15338 protected void composeMolecularSequenceQualityComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceQualityComponent 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 composeBackboneElement(t, "quality", name, element, index); 15348 if (element.hasTypeElement()) { 15349 composeEnum(t, "MolecularSequenceQualityComponent", "type", element.getTypeElement(), -1); 15350 } 15351 if (element.hasStandardSequence()) { 15352 composeCodeableConcept(t, "MolecularSequenceQualityComponent", "standardSequence", element.getStandardSequence(), -1); 15353 } 15354 if (element.hasStartElement()) { 15355 composeInteger(t, "MolecularSequenceQualityComponent", "start", element.getStartElement(), -1); 15356 } 15357 if (element.hasEndElement()) { 15358 composeInteger(t, "MolecularSequenceQualityComponent", "end", element.getEndElement(), -1); 15359 } 15360 if (element.hasScore()) { 15361 composeQuantity(t, "MolecularSequenceQualityComponent", "score", element.getScore(), -1); 15362 } 15363 if (element.hasMethod()) { 15364 composeCodeableConcept(t, "MolecularSequenceQualityComponent", "method", element.getMethod(), -1); 15365 } 15366 if (element.hasTruthTPElement()) { 15367 composeDecimal(t, "MolecularSequenceQualityComponent", "truthTP", element.getTruthTPElement(), -1); 15368 } 15369 if (element.hasQueryTPElement()) { 15370 composeDecimal(t, "MolecularSequenceQualityComponent", "queryTP", element.getQueryTPElement(), -1); 15371 } 15372 if (element.hasTruthFNElement()) { 15373 composeDecimal(t, "MolecularSequenceQualityComponent", "truthFN", element.getTruthFNElement(), -1); 15374 } 15375 if (element.hasQueryFPElement()) { 15376 composeDecimal(t, "MolecularSequenceQualityComponent", "queryFP", element.getQueryFPElement(), -1); 15377 } 15378 if (element.hasGtFPElement()) { 15379 composeDecimal(t, "MolecularSequenceQualityComponent", "gtFP", element.getGtFPElement(), -1); 15380 } 15381 if (element.hasPrecisionElement()) { 15382 composeDecimal(t, "MolecularSequenceQualityComponent", "precision", element.getPrecisionElement(), -1); 15383 } 15384 if (element.hasRecallElement()) { 15385 composeDecimal(t, "MolecularSequenceQualityComponent", "recall", element.getRecallElement(), -1); 15386 } 15387 if (element.hasFScoreElement()) { 15388 composeDecimal(t, "MolecularSequenceQualityComponent", "fScore", element.getFScoreElement(), -1); 15389 } 15390 if (element.hasRoc()) { 15391 composeMolecularSequenceQualityRocComponent(t, "MolecularSequenceQualityComponent", "roc", element.getRoc(), -1); 15392 } 15393 } 15394 15395 protected void composeMolecularSequenceQualityRocComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceQualityRocComponent element, int index) { 15396 if (element == null) 15397 return; 15398 Complex t; 15399 if (Utilities.noString(parentType)) 15400 t = parent; 15401 else { 15402 t = parent.predicate("fhir:"+parentType+'.'+name); 15403 } 15404 composeBackboneElement(t, "roc", name, element, index); 15405 for (int i = 0; i < element.getScore().size(); i++) { 15406 composeInteger(t, "MolecularSequenceQualityRocComponent", "score", element.getScore().get(i), i); 15407 } 15408 for (int i = 0; i < element.getNumTP().size(); i++) { 15409 composeInteger(t, "MolecularSequenceQualityRocComponent", "numTP", element.getNumTP().get(i), i); 15410 } 15411 for (int i = 0; i < element.getNumFP().size(); i++) { 15412 composeInteger(t, "MolecularSequenceQualityRocComponent", "numFP", element.getNumFP().get(i), i); 15413 } 15414 for (int i = 0; i < element.getNumFN().size(); i++) { 15415 composeInteger(t, "MolecularSequenceQualityRocComponent", "numFN", element.getNumFN().get(i), i); 15416 } 15417 for (int i = 0; i < element.getPrecision().size(); i++) { 15418 composeDecimal(t, "MolecularSequenceQualityRocComponent", "precision", element.getPrecision().get(i), i); 15419 } 15420 for (int i = 0; i < element.getSensitivity().size(); i++) { 15421 composeDecimal(t, "MolecularSequenceQualityRocComponent", "sensitivity", element.getSensitivity().get(i), i); 15422 } 15423 for (int i = 0; i < element.getFMeasure().size(); i++) { 15424 composeDecimal(t, "MolecularSequenceQualityRocComponent", "fMeasure", element.getFMeasure().get(i), i); 15425 } 15426 } 15427 15428 protected void composeMolecularSequenceRepositoryComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceRepositoryComponent element, int index) { 15429 if (element == null) 15430 return; 15431 Complex t; 15432 if (Utilities.noString(parentType)) 15433 t = parent; 15434 else { 15435 t = parent.predicate("fhir:"+parentType+'.'+name); 15436 } 15437 composeBackboneElement(t, "repository", name, element, index); 15438 if (element.hasTypeElement()) { 15439 composeEnum(t, "MolecularSequenceRepositoryComponent", "type", element.getTypeElement(), -1); 15440 } 15441 if (element.hasUrlElement()) { 15442 composeUri(t, "MolecularSequenceRepositoryComponent", "url", element.getUrlElement(), -1); 15443 } 15444 if (element.hasNameElement()) { 15445 composeString(t, "MolecularSequenceRepositoryComponent", "name", element.getNameElement(), -1); 15446 } 15447 if (element.hasDatasetIdElement()) { 15448 composeString(t, "MolecularSequenceRepositoryComponent", "datasetId", element.getDatasetIdElement(), -1); 15449 } 15450 if (element.hasVariantsetIdElement()) { 15451 composeString(t, "MolecularSequenceRepositoryComponent", "variantsetId", element.getVariantsetIdElement(), -1); 15452 } 15453 if (element.hasReadsetIdElement()) { 15454 composeString(t, "MolecularSequenceRepositoryComponent", "readsetId", element.getReadsetIdElement(), -1); 15455 } 15456 } 15457 15458 protected void composeMolecularSequenceStructureVariantComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceStructureVariantComponent element, int index) { 15459 if (element == null) 15460 return; 15461 Complex t; 15462 if (Utilities.noString(parentType)) 15463 t = parent; 15464 else { 15465 t = parent.predicate("fhir:"+parentType+'.'+name); 15466 } 15467 composeBackboneElement(t, "structureVariant", name, element, index); 15468 if (element.hasVariantType()) { 15469 composeCodeableConcept(t, "MolecularSequenceStructureVariantComponent", "variantType", element.getVariantType(), -1); 15470 } 15471 if (element.hasExactElement()) { 15472 composeBoolean(t, "MolecularSequenceStructureVariantComponent", "exact", element.getExactElement(), -1); 15473 } 15474 if (element.hasLengthElement()) { 15475 composeInteger(t, "MolecularSequenceStructureVariantComponent", "length", element.getLengthElement(), -1); 15476 } 15477 if (element.hasOuter()) { 15478 composeMolecularSequenceStructureVariantOuterComponent(t, "MolecularSequenceStructureVariantComponent", "outer", element.getOuter(), -1); 15479 } 15480 if (element.hasInner()) { 15481 composeMolecularSequenceStructureVariantInnerComponent(t, "MolecularSequenceStructureVariantComponent", "inner", element.getInner(), -1); 15482 } 15483 } 15484 15485 protected void composeMolecularSequenceStructureVariantOuterComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceStructureVariantOuterComponent element, int index) { 15486 if (element == null) 15487 return; 15488 Complex t; 15489 if (Utilities.noString(parentType)) 15490 t = parent; 15491 else { 15492 t = parent.predicate("fhir:"+parentType+'.'+name); 15493 } 15494 composeBackboneElement(t, "outer", name, element, index); 15495 if (element.hasStartElement()) { 15496 composeInteger(t, "MolecularSequenceStructureVariantOuterComponent", "start", element.getStartElement(), -1); 15497 } 15498 if (element.hasEndElement()) { 15499 composeInteger(t, "MolecularSequenceStructureVariantOuterComponent", "end", element.getEndElement(), -1); 15500 } 15501 } 15502 15503 protected void composeMolecularSequenceStructureVariantInnerComponent(Complex parent, String parentType, String name, MolecularSequence.MolecularSequenceStructureVariantInnerComponent element, int index) { 15504 if (element == null) 15505 return; 15506 Complex t; 15507 if (Utilities.noString(parentType)) 15508 t = parent; 15509 else { 15510 t = parent.predicate("fhir:"+parentType+'.'+name); 15511 } 15512 composeBackboneElement(t, "inner", name, element, index); 15513 if (element.hasStartElement()) { 15514 composeInteger(t, "MolecularSequenceStructureVariantInnerComponent", "start", element.getStartElement(), -1); 15515 } 15516 if (element.hasEndElement()) { 15517 composeInteger(t, "MolecularSequenceStructureVariantInnerComponent", "end", element.getEndElement(), -1); 15518 } 15519 } 15520 15521 protected void composeNamingSystem(Complex parent, String parentType, String name, NamingSystem element, int index) { 15522 if (element == null) 15523 return; 15524 Complex t; 15525 if (Utilities.noString(parentType)) 15526 t = parent; 15527 else { 15528 t = parent.predicate("fhir:"+parentType+'.'+name); 15529 } 15530 composeCanonicalResource(t, "NamingSystem", name, element, index); 15531 if (element.hasUrlElement()) { 15532 composeUri(t, "NamingSystem", "url", element.getUrlElement(), -1); 15533 } 15534 if (element.hasVersionElement()) { 15535 composeString(t, "NamingSystem", "version", element.getVersionElement(), -1); 15536 } 15537 if (element.hasNameElement()) { 15538 composeString(t, "NamingSystem", "name", element.getNameElement(), -1); 15539 } 15540 if (element.hasStatusElement()) { 15541 composeEnum(t, "NamingSystem", "status", element.getStatusElement(), -1); 15542 } 15543 if (element.hasKindElement()) { 15544 composeEnum(t, "NamingSystem", "kind", element.getKindElement(), -1); 15545 } 15546 if (element.hasDateElement()) { 15547 composeDateTime(t, "NamingSystem", "date", element.getDateElement(), -1); 15548 } 15549 if (element.hasPublisherElement()) { 15550 composeString(t, "NamingSystem", "publisher", element.getPublisherElement(), -1); 15551 } 15552 for (int i = 0; i < element.getContact().size(); i++) { 15553 composeContactDetail(t, "NamingSystem", "contact", element.getContact().get(i), i); 15554 } 15555 if (element.hasResponsibleElement()) { 15556 composeString(t, "NamingSystem", "responsible", element.getResponsibleElement(), -1); 15557 } 15558 if (element.hasType()) { 15559 composeCodeableConcept(t, "NamingSystem", "type", element.getType(), -1); 15560 } 15561 if (element.hasDescriptionElement()) { 15562 composeMarkdown(t, "NamingSystem", "description", element.getDescriptionElement(), -1); 15563 } 15564 for (int i = 0; i < element.getUseContext().size(); i++) { 15565 composeUsageContext(t, "NamingSystem", "useContext", element.getUseContext().get(i), i); 15566 } 15567 for (int i = 0; i < element.getJurisdiction().size(); i++) { 15568 composeCodeableConcept(t, "NamingSystem", "jurisdiction", element.getJurisdiction().get(i), i); 15569 } 15570 if (element.hasUsageElement()) { 15571 composeString(t, "NamingSystem", "usage", element.getUsageElement(), -1); 15572 } 15573 for (int i = 0; i < element.getUniqueId().size(); i++) { 15574 composeNamingSystemUniqueIdComponent(t, "NamingSystem", "uniqueId", element.getUniqueId().get(i), i); 15575 } 15576 } 15577 15578 protected void composeNamingSystemUniqueIdComponent(Complex parent, String parentType, String name, NamingSystem.NamingSystemUniqueIdComponent element, int index) { 15579 if (element == null) 15580 return; 15581 Complex t; 15582 if (Utilities.noString(parentType)) 15583 t = parent; 15584 else { 15585 t = parent.predicate("fhir:"+parentType+'.'+name); 15586 } 15587 composeBackboneElement(t, "uniqueId", name, element, index); 15588 if (element.hasTypeElement()) { 15589 composeEnum(t, "NamingSystemUniqueIdComponent", "type", element.getTypeElement(), -1); 15590 } 15591 if (element.hasValueElement()) { 15592 composeString(t, "NamingSystemUniqueIdComponent", "value", element.getValueElement(), -1); 15593 } 15594 if (element.hasPreferredElement()) { 15595 composeBoolean(t, "NamingSystemUniqueIdComponent", "preferred", element.getPreferredElement(), -1); 15596 } 15597 if (element.hasCommentElement()) { 15598 composeString(t, "NamingSystemUniqueIdComponent", "comment", element.getCommentElement(), -1); 15599 } 15600 if (element.hasPeriod()) { 15601 composePeriod(t, "NamingSystemUniqueIdComponent", "period", element.getPeriod(), -1); 15602 } 15603 } 15604 15605 protected void composeNutritionIntake(Complex parent, String parentType, String name, NutritionIntake element, int index) { 15606 if (element == null) 15607 return; 15608 Complex t; 15609 if (Utilities.noString(parentType)) 15610 t = parent; 15611 else { 15612 t = parent.predicate("fhir:"+parentType+'.'+name); 15613 } 15614 composeDomainResource(t, "NutritionIntake", name, element, index); 15615 for (int i = 0; i < element.getIdentifier().size(); i++) { 15616 composeIdentifier(t, "NutritionIntake", "identifier", element.getIdentifier().get(i), i); 15617 } 15618 for (int i = 0; i < element.getBasedOn().size(); i++) { 15619 composeReference(t, "NutritionIntake", "basedOn", element.getBasedOn().get(i), i); 15620 } 15621 for (int i = 0; i < element.getPartOf().size(); i++) { 15622 composeReference(t, "NutritionIntake", "partOf", element.getPartOf().get(i), i); 15623 } 15624 if (element.hasStatusElement()) { 15625 composeEnum(t, "NutritionIntake", "status", element.getStatusElement(), -1); 15626 } 15627 for (int i = 0; i < element.getStatusReason().size(); i++) { 15628 composeCodeableConcept(t, "NutritionIntake", "statusReason", element.getStatusReason().get(i), i); 15629 } 15630 for (int i = 0; i < element.getCategory().size(); i++) { 15631 composeCodeableConcept(t, "NutritionIntake", "category", element.getCategory().get(i), i); 15632 } 15633 for (int i = 0; i < element.getConsumedItem().size(); i++) { 15634 composeNutritionIntakeConsumedItemComponent(t, "NutritionIntake", "consumedItem", element.getConsumedItem().get(i), i); 15635 } 15636 for (int i = 0; i < element.getIngredientLabel().size(); i++) { 15637 composeNutritionIntakeIngredientLabelComponent(t, "NutritionIntake", "ingredientLabel", element.getIngredientLabel().get(i), i); 15638 } 15639 if (element.hasSubject()) { 15640 composeReference(t, "NutritionIntake", "subject", element.getSubject(), -1); 15641 } 15642 if (element.hasEncounter()) { 15643 composeReference(t, "NutritionIntake", "encounter", element.getEncounter(), -1); 15644 } 15645 if (element.hasEffective()) { 15646 composeType(t, "NutritionIntake", "effective", element.getEffective(), -1); 15647 } 15648 if (element.hasDateAssertedElement()) { 15649 composeDateTime(t, "NutritionIntake", "dateAsserted", element.getDateAssertedElement(), -1); 15650 } 15651 if (element.hasInformationSource()) { 15652 composeReference(t, "NutritionIntake", "informationSource", element.getInformationSource(), -1); 15653 } 15654 for (int i = 0; i < element.getDerivedFrom().size(); i++) { 15655 composeReference(t, "NutritionIntake", "derivedFrom", element.getDerivedFrom().get(i), i); 15656 } 15657 for (int i = 0; i < element.getReasonCode().size(); i++) { 15658 composeCodeableReference(t, "NutritionIntake", "reasonCode", element.getReasonCode().get(i), i); 15659 } 15660 for (int i = 0; i < element.getNote().size(); i++) { 15661 composeAnnotation(t, "NutritionIntake", "note", element.getNote().get(i), i); 15662 } 15663 } 15664 15665 protected void composeNutritionIntakeConsumedItemComponent(Complex parent, String parentType, String name, NutritionIntake.NutritionIntakeConsumedItemComponent element, int index) { 15666 if (element == null) 15667 return; 15668 Complex t; 15669 if (Utilities.noString(parentType)) 15670 t = parent; 15671 else { 15672 t = parent.predicate("fhir:"+parentType+'.'+name); 15673 } 15674 composeBackboneElement(t, "consumedItem", name, element, index); 15675 if (element.hasType()) { 15676 composeCodeableConcept(t, "NutritionIntakeConsumedItemComponent", "type", element.getType(), -1); 15677 } 15678 if (element.hasNutritionProduct()) { 15679 composeCodeableConcept(t, "NutritionIntakeConsumedItemComponent", "nutritionProduct", element.getNutritionProduct(), -1); 15680 } 15681 if (element.hasSchedule()) { 15682 composeTiming(t, "NutritionIntakeConsumedItemComponent", "schedule", element.getSchedule(), -1); 15683 } 15684 if (element.hasAmount()) { 15685 composeQuantity(t, "NutritionIntakeConsumedItemComponent", "amount", element.getAmount(), -1); 15686 } 15687 if (element.hasRate()) { 15688 composeQuantity(t, "NutritionIntakeConsumedItemComponent", "rate", element.getRate(), -1); 15689 } 15690 if (element.hasNotConsumedElement()) { 15691 composeBoolean(t, "NutritionIntakeConsumedItemComponent", "notConsumed", element.getNotConsumedElement(), -1); 15692 } 15693 if (element.hasNotConsumedReason()) { 15694 composeCodeableConcept(t, "NutritionIntakeConsumedItemComponent", "notConsumedReason", element.getNotConsumedReason(), -1); 15695 } 15696 } 15697 15698 protected void composeNutritionIntakeIngredientLabelComponent(Complex parent, String parentType, String name, NutritionIntake.NutritionIntakeIngredientLabelComponent element, int index) { 15699 if (element == null) 15700 return; 15701 Complex t; 15702 if (Utilities.noString(parentType)) 15703 t = parent; 15704 else { 15705 t = parent.predicate("fhir:"+parentType+'.'+name); 15706 } 15707 composeBackboneElement(t, "ingredientLabel", name, element, index); 15708 if (element.hasNutrient()) { 15709 composeCodeableConcept(t, "NutritionIntakeIngredientLabelComponent", "nutrient", element.getNutrient(), -1); 15710 } 15711 if (element.hasAmount()) { 15712 composeQuantity(t, "NutritionIntakeIngredientLabelComponent", "amount", element.getAmount(), -1); 15713 } 15714 } 15715 15716 protected void composeNutritionOrder(Complex parent, String parentType, String name, NutritionOrder 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, "NutritionOrder", name, element, index); 15726 for (int i = 0; i < element.getIdentifier().size(); i++) { 15727 composeIdentifier(t, "NutritionOrder", "identifier", element.getIdentifier().get(i), i); 15728 } 15729 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) { 15730 composeCanonical(t, "NutritionOrder", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 15731 } 15732 for (int i = 0; i < element.getInstantiatesUri().size(); i++) { 15733 composeUri(t, "NutritionOrder", "instantiatesUri", element.getInstantiatesUri().get(i), i); 15734 } 15735 for (int i = 0; i < element.getInstantiates().size(); i++) { 15736 composeUri(t, "NutritionOrder", "instantiates", element.getInstantiates().get(i), i); 15737 } 15738 if (element.hasStatusElement()) { 15739 composeEnum(t, "NutritionOrder", "status", element.getStatusElement(), -1); 15740 } 15741 if (element.hasIntentElement()) { 15742 composeEnum(t, "NutritionOrder", "intent", element.getIntentElement(), -1); 15743 } 15744 if (element.hasPatient()) { 15745 composeReference(t, "NutritionOrder", "patient", element.getPatient(), -1); 15746 } 15747 if (element.hasEncounter()) { 15748 composeReference(t, "NutritionOrder", "encounter", element.getEncounter(), -1); 15749 } 15750 if (element.hasDateTimeElement()) { 15751 composeDateTime(t, "NutritionOrder", "dateTime", element.getDateTimeElement(), -1); 15752 } 15753 if (element.hasOrderer()) { 15754 composeReference(t, "NutritionOrder", "orderer", element.getOrderer(), -1); 15755 } 15756 for (int i = 0; i < element.getAllergyIntolerance().size(); i++) { 15757 composeReference(t, "NutritionOrder", "allergyIntolerance", element.getAllergyIntolerance().get(i), i); 15758 } 15759 for (int i = 0; i < element.getFoodPreferenceModifier().size(); i++) { 15760 composeCodeableConcept(t, "NutritionOrder", "foodPreferenceModifier", element.getFoodPreferenceModifier().get(i), i); 15761 } 15762 for (int i = 0; i < element.getExcludeFoodModifier().size(); i++) { 15763 composeCodeableConcept(t, "NutritionOrder", "excludeFoodModifier", element.getExcludeFoodModifier().get(i), i); 15764 } 15765 if (element.hasOralDiet()) { 15766 composeNutritionOrderOralDietComponent(t, "NutritionOrder", "oralDiet", element.getOralDiet(), -1); 15767 } 15768 for (int i = 0; i < element.getSupplement().size(); i++) { 15769 composeNutritionOrderSupplementComponent(t, "NutritionOrder", "supplement", element.getSupplement().get(i), i); 15770 } 15771 if (element.hasEnteralFormula()) { 15772 composeNutritionOrderEnteralFormulaComponent(t, "NutritionOrder", "enteralFormula", element.getEnteralFormula(), -1); 15773 } 15774 for (int i = 0; i < element.getNote().size(); i++) { 15775 composeAnnotation(t, "NutritionOrder", "note", element.getNote().get(i), i); 15776 } 15777 } 15778 15779 protected void composeNutritionOrderOralDietComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietComponent element, int index) { 15780 if (element == null) 15781 return; 15782 Complex t; 15783 if (Utilities.noString(parentType)) 15784 t = parent; 15785 else { 15786 t = parent.predicate("fhir:"+parentType+'.'+name); 15787 } 15788 composeBackboneElement(t, "oralDiet", name, element, index); 15789 for (int i = 0; i < element.getType().size(); i++) { 15790 composeCodeableConcept(t, "NutritionOrderOralDietComponent", "type", element.getType().get(i), i); 15791 } 15792 for (int i = 0; i < element.getSchedule().size(); i++) { 15793 composeTiming(t, "NutritionOrderOralDietComponent", "schedule", element.getSchedule().get(i), i); 15794 } 15795 for (int i = 0; i < element.getNutrient().size(); i++) { 15796 composeNutritionOrderOralDietNutrientComponent(t, "NutritionOrderOralDietComponent", "nutrient", element.getNutrient().get(i), i); 15797 } 15798 for (int i = 0; i < element.getTexture().size(); i++) { 15799 composeNutritionOrderOralDietTextureComponent(t, "NutritionOrderOralDietComponent", "texture", element.getTexture().get(i), i); 15800 } 15801 for (int i = 0; i < element.getFluidConsistencyType().size(); i++) { 15802 composeCodeableConcept(t, "NutritionOrderOralDietComponent", "fluidConsistencyType", element.getFluidConsistencyType().get(i), i); 15803 } 15804 if (element.hasInstructionElement()) { 15805 composeString(t, "NutritionOrderOralDietComponent", "instruction", element.getInstructionElement(), -1); 15806 } 15807 } 15808 15809 protected void composeNutritionOrderOralDietNutrientComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietNutrientComponent element, int index) { 15810 if (element == null) 15811 return; 15812 Complex t; 15813 if (Utilities.noString(parentType)) 15814 t = parent; 15815 else { 15816 t = parent.predicate("fhir:"+parentType+'.'+name); 15817 } 15818 composeBackboneElement(t, "nutrient", name, element, index); 15819 if (element.hasModifier()) { 15820 composeCodeableConcept(t, "NutritionOrderOralDietNutrientComponent", "modifier", element.getModifier(), -1); 15821 } 15822 if (element.hasAmount()) { 15823 composeQuantity(t, "NutritionOrderOralDietNutrientComponent", "amount", element.getAmount(), -1); 15824 } 15825 } 15826 15827 protected void composeNutritionOrderOralDietTextureComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietTextureComponent element, int index) { 15828 if (element == null) 15829 return; 15830 Complex t; 15831 if (Utilities.noString(parentType)) 15832 t = parent; 15833 else { 15834 t = parent.predicate("fhir:"+parentType+'.'+name); 15835 } 15836 composeBackboneElement(t, "texture", name, element, index); 15837 if (element.hasModifier()) { 15838 composeCodeableConcept(t, "NutritionOrderOralDietTextureComponent", "modifier", element.getModifier(), -1); 15839 } 15840 if (element.hasFoodType()) { 15841 composeCodeableConcept(t, "NutritionOrderOralDietTextureComponent", "foodType", element.getFoodType(), -1); 15842 } 15843 } 15844 15845 protected void composeNutritionOrderSupplementComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderSupplementComponent element, int index) { 15846 if (element == null) 15847 return; 15848 Complex t; 15849 if (Utilities.noString(parentType)) 15850 t = parent; 15851 else { 15852 t = parent.predicate("fhir:"+parentType+'.'+name); 15853 } 15854 composeBackboneElement(t, "supplement", name, element, index); 15855 if (element.hasType()) { 15856 composeCodeableConcept(t, "NutritionOrderSupplementComponent", "type", element.getType(), -1); 15857 } 15858 if (element.hasProductNameElement()) { 15859 composeString(t, "NutritionOrderSupplementComponent", "productName", element.getProductNameElement(), -1); 15860 } 15861 for (int i = 0; i < element.getSchedule().size(); i++) { 15862 composeTiming(t, "NutritionOrderSupplementComponent", "schedule", element.getSchedule().get(i), i); 15863 } 15864 if (element.hasQuantity()) { 15865 composeQuantity(t, "NutritionOrderSupplementComponent", "quantity", element.getQuantity(), -1); 15866 } 15867 if (element.hasInstructionElement()) { 15868 composeString(t, "NutritionOrderSupplementComponent", "instruction", element.getInstructionElement(), -1); 15869 } 15870 } 15871 15872 protected void composeNutritionOrderEnteralFormulaComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaComponent 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 composeBackboneElement(t, "enteralFormula", name, element, index); 15882 if (element.hasBaseFormulaType()) { 15883 composeCodeableConcept(t, "NutritionOrderEnteralFormulaComponent", "baseFormulaType", element.getBaseFormulaType(), -1); 15884 } 15885 if (element.hasBaseFormulaProductNameElement()) { 15886 composeString(t, "NutritionOrderEnteralFormulaComponent", "baseFormulaProductName", element.getBaseFormulaProductNameElement(), -1); 15887 } 15888 if (element.hasAdditiveType()) { 15889 composeCodeableConcept(t, "NutritionOrderEnteralFormulaComponent", "additiveType", element.getAdditiveType(), -1); 15890 } 15891 if (element.hasAdditiveProductNameElement()) { 15892 composeString(t, "NutritionOrderEnteralFormulaComponent", "additiveProductName", element.getAdditiveProductNameElement(), -1); 15893 } 15894 if (element.hasCaloricDensity()) { 15895 composeQuantity(t, "NutritionOrderEnteralFormulaComponent", "caloricDensity", element.getCaloricDensity(), -1); 15896 } 15897 if (element.hasRouteofAdministration()) { 15898 composeCodeableConcept(t, "NutritionOrderEnteralFormulaComponent", "routeofAdministration", element.getRouteofAdministration(), -1); 15899 } 15900 for (int i = 0; i < element.getAdministration().size(); i++) { 15901 composeNutritionOrderEnteralFormulaAdministrationComponent(t, "NutritionOrderEnteralFormulaComponent", "administration", element.getAdministration().get(i), i); 15902 } 15903 if (element.hasMaxVolumeToDeliver()) { 15904 composeQuantity(t, "NutritionOrderEnteralFormulaComponent", "maxVolumeToDeliver", element.getMaxVolumeToDeliver(), -1); 15905 } 15906 if (element.hasAdministrationInstructionElement()) { 15907 composeString(t, "NutritionOrderEnteralFormulaComponent", "administrationInstruction", element.getAdministrationInstructionElement(), -1); 15908 } 15909 } 15910 15911 protected void composeNutritionOrderEnteralFormulaAdministrationComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent element, int index) { 15912 if (element == null) 15913 return; 15914 Complex t; 15915 if (Utilities.noString(parentType)) 15916 t = parent; 15917 else { 15918 t = parent.predicate("fhir:"+parentType+'.'+name); 15919 } 15920 composeBackboneElement(t, "administration", name, element, index); 15921 if (element.hasSchedule()) { 15922 composeTiming(t, "NutritionOrderEnteralFormulaAdministrationComponent", "schedule", element.getSchedule(), -1); 15923 } 15924 if (element.hasQuantity()) { 15925 composeQuantity(t, "NutritionOrderEnteralFormulaAdministrationComponent", "quantity", element.getQuantity(), -1); 15926 } 15927 if (element.hasRate()) { 15928 composeType(t, "NutritionOrderEnteralFormulaAdministrationComponent", "rate", element.getRate(), -1); 15929 } 15930 } 15931 15932 protected void composeObservation(Complex parent, String parentType, String name, Observation element, int index) { 15933 if (element == null) 15934 return; 15935 Complex t; 15936 if (Utilities.noString(parentType)) 15937 t = parent; 15938 else { 15939 t = parent.predicate("fhir:"+parentType+'.'+name); 15940 } 15941 composeDomainResource(t, "Observation", name, element, index); 15942 for (int i = 0; i < element.getIdentifier().size(); i++) { 15943 composeIdentifier(t, "Observation", "identifier", element.getIdentifier().get(i), i); 15944 } 15945 for (int i = 0; i < element.getBasedOn().size(); i++) { 15946 composeReference(t, "Observation", "basedOn", element.getBasedOn().get(i), i); 15947 } 15948 for (int i = 0; i < element.getPartOf().size(); i++) { 15949 composeReference(t, "Observation", "partOf", element.getPartOf().get(i), i); 15950 } 15951 if (element.hasStatusElement()) { 15952 composeEnum(t, "Observation", "status", element.getStatusElement(), -1); 15953 } 15954 for (int i = 0; i < element.getCategory().size(); i++) { 15955 composeCodeableConcept(t, "Observation", "category", element.getCategory().get(i), i); 15956 } 15957 if (element.hasCode()) { 15958 composeCodeableConcept(t, "Observation", "code", element.getCode(), -1); 15959 } 15960 if (element.hasSubject()) { 15961 composeReference(t, "Observation", "subject", element.getSubject(), -1); 15962 } 15963 for (int i = 0; i < element.getFocus().size(); i++) { 15964 composeReference(t, "Observation", "focus", element.getFocus().get(i), i); 15965 } 15966 if (element.hasEncounter()) { 15967 composeReference(t, "Observation", "encounter", element.getEncounter(), -1); 15968 } 15969 if (element.hasEffective()) { 15970 composeType(t, "Observation", "effective", element.getEffective(), -1); 15971 } 15972 if (element.hasIssuedElement()) { 15973 composeInstant(t, "Observation", "issued", element.getIssuedElement(), -1); 15974 } 15975 for (int i = 0; i < element.getPerformer().size(); i++) { 15976 composeReference(t, "Observation", "performer", element.getPerformer().get(i), i); 15977 } 15978 if (element.hasValue()) { 15979 composeType(t, "Observation", "value", element.getValue(), -1); 15980 } 15981 if (element.hasDataAbsentReason()) { 15982 composeCodeableConcept(t, "Observation", "dataAbsentReason", element.getDataAbsentReason(), -1); 15983 } 15984 for (int i = 0; i < element.getInterpretation().size(); i++) { 15985 composeCodeableConcept(t, "Observation", "interpretation", element.getInterpretation().get(i), i); 15986 } 15987 for (int i = 0; i < element.getNote().size(); i++) { 15988 composeAnnotation(t, "Observation", "note", element.getNote().get(i), i); 15989 } 15990 if (element.hasBodySite()) { 15991 composeCodeableConcept(t, "Observation", "bodySite", element.getBodySite(), -1); 15992 } 15993 if (element.hasMethod()) { 15994 composeCodeableConcept(t, "Observation", "method", element.getMethod(), -1); 15995 } 15996 if (element.hasSpecimen()) { 15997 composeReference(t, "Observation", "specimen", element.getSpecimen(), -1); 15998 } 15999 if (element.hasDevice()) { 16000 composeReference(t, "Observation", "device", element.getDevice(), -1); 16001 } 16002 for (int i = 0; i < element.getReferenceRange().size(); i++) { 16003 composeObservationReferenceRangeComponent(t, "Observation", "referenceRange", element.getReferenceRange().get(i), i); 16004 } 16005 for (int i = 0; i < element.getHasMember().size(); i++) { 16006 composeReference(t, "Observation", "hasMember", element.getHasMember().get(i), i); 16007 } 16008 for (int i = 0; i < element.getDerivedFrom().size(); i++) { 16009 composeReference(t, "Observation", "derivedFrom", element.getDerivedFrom().get(i), i); 16010 } 16011 for (int i = 0; i < element.getComponent().size(); i++) { 16012 composeObservationComponentComponent(t, "Observation", "component", element.getComponent().get(i), i); 16013 } 16014 } 16015 16016 protected void composeObservationReferenceRangeComponent(Complex parent, String parentType, String name, Observation.ObservationReferenceRangeComponent element, int index) { 16017 if (element == null) 16018 return; 16019 Complex t; 16020 if (Utilities.noString(parentType)) 16021 t = parent; 16022 else { 16023 t = parent.predicate("fhir:"+parentType+'.'+name); 16024 } 16025 composeBackboneElement(t, "referenceRange", name, element, index); 16026 if (element.hasLow()) { 16027 composeQuantity(t, "ObservationReferenceRangeComponent", "low", element.getLow(), -1); 16028 } 16029 if (element.hasHigh()) { 16030 composeQuantity(t, "ObservationReferenceRangeComponent", "high", element.getHigh(), -1); 16031 } 16032 if (element.hasType()) { 16033 composeCodeableConcept(t, "ObservationReferenceRangeComponent", "type", element.getType(), -1); 16034 } 16035 for (int i = 0; i < element.getAppliesTo().size(); i++) { 16036 composeCodeableConcept(t, "ObservationReferenceRangeComponent", "appliesTo", element.getAppliesTo().get(i), i); 16037 } 16038 if (element.hasAge()) { 16039 composeRange(t, "ObservationReferenceRangeComponent", "age", element.getAge(), -1); 16040 } 16041 if (element.hasTextElement()) { 16042 composeString(t, "ObservationReferenceRangeComponent", "text", element.getTextElement(), -1); 16043 } 16044 } 16045 16046 protected void composeObservationComponentComponent(Complex parent, String parentType, String name, Observation.ObservationComponentComponent element, int index) { 16047 if (element == null) 16048 return; 16049 Complex t; 16050 if (Utilities.noString(parentType)) 16051 t = parent; 16052 else { 16053 t = parent.predicate("fhir:"+parentType+'.'+name); 16054 } 16055 composeBackboneElement(t, "component", name, element, index); 16056 if (element.hasCode()) { 16057 composeCodeableConcept(t, "ObservationComponentComponent", "code", element.getCode(), -1); 16058 } 16059 if (element.hasValue()) { 16060 composeType(t, "ObservationComponentComponent", "value", element.getValue(), -1); 16061 } 16062 if (element.hasDataAbsentReason()) { 16063 composeCodeableConcept(t, "ObservationComponentComponent", "dataAbsentReason", element.getDataAbsentReason(), -1); 16064 } 16065 for (int i = 0; i < element.getInterpretation().size(); i++) { 16066 composeCodeableConcept(t, "ObservationComponentComponent", "interpretation", element.getInterpretation().get(i), i); 16067 } 16068 for (int i = 0; i < element.getReferenceRange().size(); i++) { 16069 composeObservationReferenceRangeComponent(t, "ObservationComponentComponent", "referenceRange", element.getReferenceRange().get(i), i); 16070 } 16071 } 16072 16073 protected void composeObservationDefinition(Complex parent, String parentType, String name, ObservationDefinition element, int index) { 16074 if (element == null) 16075 return; 16076 Complex t; 16077 if (Utilities.noString(parentType)) 16078 t = parent; 16079 else { 16080 t = parent.predicate("fhir:"+parentType+'.'+name); 16081 } 16082 composeDomainResource(t, "ObservationDefinition", name, element, index); 16083 if (element.hasUrlElement()) { 16084 composeUri(t, "ObservationDefinition", "url", element.getUrlElement(), -1); 16085 } 16086 if (element.hasIdentifier()) { 16087 composeIdentifier(t, "ObservationDefinition", "identifier", element.getIdentifier(), -1); 16088 } 16089 if (element.hasVersionElement()) { 16090 composeString(t, "ObservationDefinition", "version", element.getVersionElement(), -1); 16091 } 16092 if (element.hasTitleElement()) { 16093 composeString(t, "ObservationDefinition", "title", element.getTitleElement(), -1); 16094 } 16095 for (int i = 0; i < element.getDerivedFromCanonical().size(); i++) { 16096 composeCanonical(t, "ObservationDefinition", "derivedFromCanonical", element.getDerivedFromCanonical().get(i), i); 16097 } 16098 for (int i = 0; i < element.getDerivedFromUri().size(); i++) { 16099 composeUri(t, "ObservationDefinition", "derivedFromUri", element.getDerivedFromUri().get(i), i); 16100 } 16101 if (element.hasStatusElement()) { 16102 composeEnum(t, "ObservationDefinition", "status", element.getStatusElement(), -1); 16103 } 16104 if (element.hasExperimentalElement()) { 16105 composeBoolean(t, "ObservationDefinition", "experimental", element.getExperimentalElement(), -1); 16106 } 16107 if (element.hasSubject()) { 16108 composeType(t, "ObservationDefinition", "subject", element.getSubject(), -1); 16109 } 16110 if (element.hasDateElement()) { 16111 composeDateTime(t, "ObservationDefinition", "date", element.getDateElement(), -1); 16112 } 16113 if (element.hasPublisher()) { 16114 composeReference(t, "ObservationDefinition", "publisher", element.getPublisher(), -1); 16115 } 16116 for (int i = 0; i < element.getContact().size(); i++) { 16117 composeContactDetail(t, "ObservationDefinition", "contact", element.getContact().get(i), i); 16118 } 16119 if (element.hasDescriptionElement()) { 16120 composeMarkdown(t, "ObservationDefinition", "description", element.getDescriptionElement(), -1); 16121 } 16122 for (int i = 0; i < element.getUseContext().size(); i++) { 16123 composeUsageContext(t, "ObservationDefinition", "useContext", element.getUseContext().get(i), i); 16124 } 16125 for (int i = 0; i < element.getJurisdiction().size(); i++) { 16126 composeCodeableConcept(t, "ObservationDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 16127 } 16128 if (element.hasPurposeElement()) { 16129 composeMarkdown(t, "ObservationDefinition", "purpose", element.getPurposeElement(), -1); 16130 } 16131 if (element.hasCopyrightElement()) { 16132 composeMarkdown(t, "ObservationDefinition", "copyright", element.getCopyrightElement(), -1); 16133 } 16134 if (element.hasApprovalDateElement()) { 16135 composeDate(t, "ObservationDefinition", "approvalDate", element.getApprovalDateElement(), -1); 16136 } 16137 if (element.hasLastReviewDateElement()) { 16138 composeDate(t, "ObservationDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 16139 } 16140 if (element.hasEffectivePeriod()) { 16141 composePeriod(t, "ObservationDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 16142 } 16143 if (element.hasPerformerType()) { 16144 composeCodeableConcept(t, "ObservationDefinition", "performerType", element.getPerformerType(), -1); 16145 } 16146 for (int i = 0; i < element.getCategory().size(); i++) { 16147 composeCodeableConcept(t, "ObservationDefinition", "category", element.getCategory().get(i), i); 16148 } 16149 if (element.hasCode()) { 16150 composeCodeableConcept(t, "ObservationDefinition", "code", element.getCode(), -1); 16151 } 16152 for (int i = 0; i < element.getPermittedDataType().size(); i++) { 16153 composeEnum(t, "ObservationDefinition", "permittedDataType", element.getPermittedDataType().get(i), i); 16154 } 16155 if (element.hasMultipleResultsAllowedElement()) { 16156 composeBoolean(t, "ObservationDefinition", "multipleResultsAllowed", element.getMultipleResultsAllowedElement(), -1); 16157 } 16158 if (element.hasBodySite()) { 16159 composeCodeableConcept(t, "ObservationDefinition", "bodySite", element.getBodySite(), -1); 16160 } 16161 if (element.hasMethod()) { 16162 composeCodeableConcept(t, "ObservationDefinition", "method", element.getMethod(), -1); 16163 } 16164 if (element.hasSpecimen()) { 16165 composeReference(t, "ObservationDefinition", "specimen", element.getSpecimen(), -1); 16166 } 16167 if (element.hasDevice()) { 16168 composeReference(t, "ObservationDefinition", "device", element.getDevice(), -1); 16169 } 16170 if (element.hasPreferredReportNameElement()) { 16171 composeString(t, "ObservationDefinition", "preferredReportName", element.getPreferredReportNameElement(), -1); 16172 } 16173 if (element.hasQuantitativeDetails()) { 16174 composeObservationDefinitionQuantitativeDetailsComponent(t, "ObservationDefinition", "quantitativeDetails", element.getQuantitativeDetails(), -1); 16175 } 16176 for (int i = 0; i < element.getQualifiedInterval().size(); i++) { 16177 composeObservationDefinitionQualifiedIntervalComponent(t, "ObservationDefinition", "qualifiedInterval", element.getQualifiedInterval().get(i), i); 16178 } 16179 if (element.hasValidCodedValueSet()) { 16180 composeReference(t, "ObservationDefinition", "validCodedValueSet", element.getValidCodedValueSet(), -1); 16181 } 16182 if (element.hasNormalCodedValueSet()) { 16183 composeReference(t, "ObservationDefinition", "normalCodedValueSet", element.getNormalCodedValueSet(), -1); 16184 } 16185 if (element.hasAbnormalCodedValueSet()) { 16186 composeReference(t, "ObservationDefinition", "abnormalCodedValueSet", element.getAbnormalCodedValueSet(), -1); 16187 } 16188 if (element.hasCriticalCodedValueSet()) { 16189 composeReference(t, "ObservationDefinition", "criticalCodedValueSet", element.getCriticalCodedValueSet(), -1); 16190 } 16191 for (int i = 0; i < element.getHasMember().size(); i++) { 16192 composeReference(t, "ObservationDefinition", "hasMember", element.getHasMember().get(i), i); 16193 } 16194 for (int i = 0; i < element.getComponent().size(); i++) { 16195 composeObservationDefinitionComponentComponent(t, "ObservationDefinition", "component", element.getComponent().get(i), i); 16196 } 16197 } 16198 16199 protected void composeObservationDefinitionQuantitativeDetailsComponent(Complex parent, String parentType, String name, ObservationDefinition.ObservationDefinitionQuantitativeDetailsComponent element, int index) { 16200 if (element == null) 16201 return; 16202 Complex t; 16203 if (Utilities.noString(parentType)) 16204 t = parent; 16205 else { 16206 t = parent.predicate("fhir:"+parentType+'.'+name); 16207 } 16208 composeBackboneElement(t, "quantitativeDetails", name, element, index); 16209 if (element.hasCustomaryUnit()) { 16210 composeCodeableConcept(t, "ObservationDefinitionQuantitativeDetailsComponent", "customaryUnit", element.getCustomaryUnit(), -1); 16211 } 16212 if (element.hasUnit()) { 16213 composeCodeableConcept(t, "ObservationDefinitionQuantitativeDetailsComponent", "unit", element.getUnit(), -1); 16214 } 16215 if (element.hasConversionFactorElement()) { 16216 composeDecimal(t, "ObservationDefinitionQuantitativeDetailsComponent", "conversionFactor", element.getConversionFactorElement(), -1); 16217 } 16218 if (element.hasDecimalPrecisionElement()) { 16219 composeInteger(t, "ObservationDefinitionQuantitativeDetailsComponent", "decimalPrecision", element.getDecimalPrecisionElement(), -1); 16220 } 16221 } 16222 16223 protected void composeObservationDefinitionQualifiedIntervalComponent(Complex parent, String parentType, String name, ObservationDefinition.ObservationDefinitionQualifiedIntervalComponent element, int index) { 16224 if (element == null) 16225 return; 16226 Complex t; 16227 if (Utilities.noString(parentType)) 16228 t = parent; 16229 else { 16230 t = parent.predicate("fhir:"+parentType+'.'+name); 16231 } 16232 composeBackboneElement(t, "qualifiedInterval", name, element, index); 16233 if (element.hasCategoryElement()) { 16234 composeEnum(t, "ObservationDefinitionQualifiedIntervalComponent", "category", element.getCategoryElement(), -1); 16235 } 16236 if (element.hasRange()) { 16237 composeRange(t, "ObservationDefinitionQualifiedIntervalComponent", "range", element.getRange(), -1); 16238 } 16239 if (element.hasContext()) { 16240 composeCodeableConcept(t, "ObservationDefinitionQualifiedIntervalComponent", "context", element.getContext(), -1); 16241 } 16242 for (int i = 0; i < element.getAppliesTo().size(); i++) { 16243 composeCodeableConcept(t, "ObservationDefinitionQualifiedIntervalComponent", "appliesTo", element.getAppliesTo().get(i), i); 16244 } 16245 if (element.hasGenderElement()) { 16246 composeEnum(t, "ObservationDefinitionQualifiedIntervalComponent", "gender", element.getGenderElement(), -1); 16247 } 16248 if (element.hasAge()) { 16249 composeRange(t, "ObservationDefinitionQualifiedIntervalComponent", "age", element.getAge(), -1); 16250 } 16251 if (element.hasGestationalAge()) { 16252 composeRange(t, "ObservationDefinitionQualifiedIntervalComponent", "gestationalAge", element.getGestationalAge(), -1); 16253 } 16254 if (element.hasConditionElement()) { 16255 composeString(t, "ObservationDefinitionQualifiedIntervalComponent", "condition", element.getConditionElement(), -1); 16256 } 16257 } 16258 16259 protected void composeObservationDefinitionComponentComponent(Complex parent, String parentType, String name, ObservationDefinition.ObservationDefinitionComponentComponent element, int index) { 16260 if (element == null) 16261 return; 16262 Complex t; 16263 if (Utilities.noString(parentType)) 16264 t = parent; 16265 else { 16266 t = parent.predicate("fhir:"+parentType+'.'+name); 16267 } 16268 composeBackboneElement(t, "component", name, element, index); 16269 if (element.hasCode()) { 16270 composeCodeableConcept(t, "ObservationDefinitionComponentComponent", "code", element.getCode(), -1); 16271 } 16272 for (int i = 0; i < element.getPermittedDataType().size(); i++) { 16273 composeEnum(t, "ObservationDefinitionComponentComponent", "permittedDataType", element.getPermittedDataType().get(i), i); 16274 } 16275 if (element.hasQuantitativeDetails()) { 16276 composeObservationDefinitionQuantitativeDetailsComponent(t, "ObservationDefinitionComponentComponent", "quantitativeDetails", element.getQuantitativeDetails(), -1); 16277 } 16278 for (int i = 0; i < element.getQualifiedInterval().size(); i++) { 16279 composeObservationDefinitionQualifiedIntervalComponent(t, "ObservationDefinitionComponentComponent", "qualifiedInterval", element.getQualifiedInterval().get(i), i); 16280 } 16281 } 16282 16283 protected void composeOperationDefinition(Complex parent, String parentType, String name, OperationDefinition element, int index) { 16284 if (element == null) 16285 return; 16286 Complex t; 16287 if (Utilities.noString(parentType)) 16288 t = parent; 16289 else { 16290 t = parent.predicate("fhir:"+parentType+'.'+name); 16291 } 16292 composeCanonicalResource(t, "OperationDefinition", name, element, index); 16293 if (element.hasUrlElement()) { 16294 composeUri(t, "OperationDefinition", "url", element.getUrlElement(), -1); 16295 } 16296 if (element.hasVersionElement()) { 16297 composeString(t, "OperationDefinition", "version", element.getVersionElement(), -1); 16298 } 16299 if (element.hasNameElement()) { 16300 composeString(t, "OperationDefinition", "name", element.getNameElement(), -1); 16301 } 16302 if (element.hasTitleElement()) { 16303 composeString(t, "OperationDefinition", "title", element.getTitleElement(), -1); 16304 } 16305 if (element.hasStatusElement()) { 16306 composeEnum(t, "OperationDefinition", "status", element.getStatusElement(), -1); 16307 } 16308 if (element.hasKindElement()) { 16309 composeEnum(t, "OperationDefinition", "kind", element.getKindElement(), -1); 16310 } 16311 if (element.hasExperimentalElement()) { 16312 composeBoolean(t, "OperationDefinition", "experimental", element.getExperimentalElement(), -1); 16313 } 16314 if (element.hasDateElement()) { 16315 composeDateTime(t, "OperationDefinition", "date", element.getDateElement(), -1); 16316 } 16317 if (element.hasPublisherElement()) { 16318 composeString(t, "OperationDefinition", "publisher", element.getPublisherElement(), -1); 16319 } 16320 for (int i = 0; i < element.getContact().size(); i++) { 16321 composeContactDetail(t, "OperationDefinition", "contact", element.getContact().get(i), i); 16322 } 16323 if (element.hasDescriptionElement()) { 16324 composeMarkdown(t, "OperationDefinition", "description", element.getDescriptionElement(), -1); 16325 } 16326 for (int i = 0; i < element.getUseContext().size(); i++) { 16327 composeUsageContext(t, "OperationDefinition", "useContext", element.getUseContext().get(i), i); 16328 } 16329 for (int i = 0; i < element.getJurisdiction().size(); i++) { 16330 composeCodeableConcept(t, "OperationDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 16331 } 16332 if (element.hasPurposeElement()) { 16333 composeMarkdown(t, "OperationDefinition", "purpose", element.getPurposeElement(), -1); 16334 } 16335 if (element.hasAffectsStateElement()) { 16336 composeBoolean(t, "OperationDefinition", "affectsState", element.getAffectsStateElement(), -1); 16337 } 16338 if (element.hasCodeElement()) { 16339 composeCode(t, "OperationDefinition", "code", element.getCodeElement(), -1); 16340 } 16341 if (element.hasCommentElement()) { 16342 composeMarkdown(t, "OperationDefinition", "comment", element.getCommentElement(), -1); 16343 } 16344 if (element.hasBaseElement()) { 16345 composeCanonical(t, "OperationDefinition", "base", element.getBaseElement(), -1); 16346 } 16347 for (int i = 0; i < element.getResource().size(); i++) { 16348 composeCode(t, "OperationDefinition", "resource", element.getResource().get(i), i); 16349 } 16350 if (element.hasSystemElement()) { 16351 composeBoolean(t, "OperationDefinition", "system", element.getSystemElement(), -1); 16352 } 16353 if (element.hasTypeElement()) { 16354 composeBoolean(t, "OperationDefinition", "type", element.getTypeElement(), -1); 16355 } 16356 if (element.hasInstanceElement()) { 16357 composeBoolean(t, "OperationDefinition", "instance", element.getInstanceElement(), -1); 16358 } 16359 if (element.hasInputProfileElement()) { 16360 composeCanonical(t, "OperationDefinition", "inputProfile", element.getInputProfileElement(), -1); 16361 } 16362 if (element.hasOutputProfileElement()) { 16363 composeCanonical(t, "OperationDefinition", "outputProfile", element.getOutputProfileElement(), -1); 16364 } 16365 for (int i = 0; i < element.getParameter().size(); i++) { 16366 composeOperationDefinitionParameterComponent(t, "OperationDefinition", "parameter", element.getParameter().get(i), i); 16367 } 16368 for (int i = 0; i < element.getOverload().size(); i++) { 16369 composeOperationDefinitionOverloadComponent(t, "OperationDefinition", "overload", element.getOverload().get(i), i); 16370 } 16371 } 16372 16373 protected void composeOperationDefinitionParameterComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterComponent element, int index) { 16374 if (element == null) 16375 return; 16376 Complex t; 16377 if (Utilities.noString(parentType)) 16378 t = parent; 16379 else { 16380 t = parent.predicate("fhir:"+parentType+'.'+name); 16381 } 16382 composeBackboneElement(t, "parameter", name, element, index); 16383 if (element.hasNameElement()) { 16384 composeCode(t, "OperationDefinitionParameterComponent", "name", element.getNameElement(), -1); 16385 } 16386 if (element.hasUseElement()) { 16387 composeEnum(t, "OperationDefinitionParameterComponent", "use", element.getUseElement(), -1); 16388 } 16389 if (element.hasMinElement()) { 16390 composeInteger(t, "OperationDefinitionParameterComponent", "min", element.getMinElement(), -1); 16391 } 16392 if (element.hasMaxElement()) { 16393 composeString(t, "OperationDefinitionParameterComponent", "max", element.getMaxElement(), -1); 16394 } 16395 if (element.hasDocumentationElement()) { 16396 composeString(t, "OperationDefinitionParameterComponent", "documentation", element.getDocumentationElement(), -1); 16397 } 16398 if (element.hasTypeElement()) { 16399 composeEnum(t, "OperationDefinitionParameterComponent", "type", element.getTypeElement(), -1); 16400 } 16401 for (int i = 0; i < element.getTargetProfile().size(); i++) { 16402 composeCanonical(t, "OperationDefinitionParameterComponent", "targetProfile", element.getTargetProfile().get(i), i); 16403 } 16404 if (element.hasSearchTypeElement()) { 16405 composeEnum(t, "OperationDefinitionParameterComponent", "searchType", element.getSearchTypeElement(), -1); 16406 } 16407 if (element.hasBinding()) { 16408 composeOperationDefinitionParameterBindingComponent(t, "OperationDefinitionParameterComponent", "binding", element.getBinding(), -1); 16409 } 16410 for (int i = 0; i < element.getReferencedFrom().size(); i++) { 16411 composeOperationDefinitionParameterReferencedFromComponent(t, "OperationDefinitionParameterComponent", "referencedFrom", element.getReferencedFrom().get(i), i); 16412 } 16413 for (int i = 0; i < element.getPart().size(); i++) { 16414 composeOperationDefinitionParameterComponent(t, "OperationDefinitionParameterComponent", "part", element.getPart().get(i), i); 16415 } 16416 } 16417 16418 protected void composeOperationDefinitionParameterBindingComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterBindingComponent element, int index) { 16419 if (element == null) 16420 return; 16421 Complex t; 16422 if (Utilities.noString(parentType)) 16423 t = parent; 16424 else { 16425 t = parent.predicate("fhir:"+parentType+'.'+name); 16426 } 16427 composeBackboneElement(t, "binding", name, element, index); 16428 if (element.hasStrengthElement()) { 16429 composeEnum(t, "OperationDefinitionParameterBindingComponent", "strength", element.getStrengthElement(), -1); 16430 } 16431 if (element.hasValueSetElement()) { 16432 composeCanonical(t, "OperationDefinitionParameterBindingComponent", "valueSet", element.getValueSetElement(), -1); 16433 } 16434 } 16435 16436 protected void composeOperationDefinitionParameterReferencedFromComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterReferencedFromComponent element, int index) { 16437 if (element == null) 16438 return; 16439 Complex t; 16440 if (Utilities.noString(parentType)) 16441 t = parent; 16442 else { 16443 t = parent.predicate("fhir:"+parentType+'.'+name); 16444 } 16445 composeBackboneElement(t, "referencedFrom", name, element, index); 16446 if (element.hasSourceElement()) { 16447 composeString(t, "OperationDefinitionParameterReferencedFromComponent", "source", element.getSourceElement(), -1); 16448 } 16449 if (element.hasSourceIdElement()) { 16450 composeString(t, "OperationDefinitionParameterReferencedFromComponent", "sourceId", element.getSourceIdElement(), -1); 16451 } 16452 } 16453 16454 protected void composeOperationDefinitionOverloadComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionOverloadComponent element, int index) { 16455 if (element == null) 16456 return; 16457 Complex t; 16458 if (Utilities.noString(parentType)) 16459 t = parent; 16460 else { 16461 t = parent.predicate("fhir:"+parentType+'.'+name); 16462 } 16463 composeBackboneElement(t, "overload", name, element, index); 16464 for (int i = 0; i < element.getParameterName().size(); i++) { 16465 composeString(t, "OperationDefinitionOverloadComponent", "parameterName", element.getParameterName().get(i), i); 16466 } 16467 if (element.hasCommentElement()) { 16468 composeString(t, "OperationDefinitionOverloadComponent", "comment", element.getCommentElement(), -1); 16469 } 16470 } 16471 16472 protected void composeOperationOutcome(Complex parent, String parentType, String name, OperationOutcome element, int index) { 16473 if (element == null) 16474 return; 16475 Complex t; 16476 if (Utilities.noString(parentType)) 16477 t = parent; 16478 else { 16479 t = parent.predicate("fhir:"+parentType+'.'+name); 16480 } 16481 composeDomainResource(t, "OperationOutcome", name, element, index); 16482 for (int i = 0; i < element.getIssue().size(); i++) { 16483 composeOperationOutcomeIssueComponent(t, "OperationOutcome", "issue", element.getIssue().get(i), i); 16484 } 16485 } 16486 16487 protected void composeOperationOutcomeIssueComponent(Complex parent, String parentType, String name, OperationOutcome.OperationOutcomeIssueComponent element, int index) { 16488 if (element == null) 16489 return; 16490 Complex t; 16491 if (Utilities.noString(parentType)) 16492 t = parent; 16493 else { 16494 t = parent.predicate("fhir:"+parentType+'.'+name); 16495 } 16496 composeBackboneElement(t, "issue", name, element, index); 16497 if (element.hasSeverityElement()) { 16498 composeEnum(t, "OperationOutcomeIssueComponent", "severity", element.getSeverityElement(), -1); 16499 } 16500 if (element.hasCodeElement()) { 16501 composeEnum(t, "OperationOutcomeIssueComponent", "code", element.getCodeElement(), -1); 16502 } 16503 if (element.hasDetails()) { 16504 composeCodeableConcept(t, "OperationOutcomeIssueComponent", "details", element.getDetails(), -1); 16505 } 16506 if (element.hasDiagnosticsElement()) { 16507 composeString(t, "OperationOutcomeIssueComponent", "diagnostics", element.getDiagnosticsElement(), -1); 16508 } 16509 for (int i = 0; i < element.getLocation().size(); i++) { 16510 composeString(t, "OperationOutcomeIssueComponent", "location", element.getLocation().get(i), i); 16511 } 16512 for (int i = 0; i < element.getExpression().size(); i++) { 16513 composeString(t, "OperationOutcomeIssueComponent", "expression", element.getExpression().get(i), i); 16514 } 16515 } 16516 16517 protected void composeOrganization(Complex parent, String parentType, String name, Organization element, int index) { 16518 if (element == null) 16519 return; 16520 Complex t; 16521 if (Utilities.noString(parentType)) 16522 t = parent; 16523 else { 16524 t = parent.predicate("fhir:"+parentType+'.'+name); 16525 } 16526 composeDomainResource(t, "Organization", name, element, index); 16527 for (int i = 0; i < element.getIdentifier().size(); i++) { 16528 composeIdentifier(t, "Organization", "identifier", element.getIdentifier().get(i), i); 16529 } 16530 if (element.hasActiveElement()) { 16531 composeBoolean(t, "Organization", "active", element.getActiveElement(), -1); 16532 } 16533 for (int i = 0; i < element.getType().size(); i++) { 16534 composeCodeableConcept(t, "Organization", "type", element.getType().get(i), i); 16535 } 16536 if (element.hasNameElement()) { 16537 composeString(t, "Organization", "name", element.getNameElement(), -1); 16538 } 16539 for (int i = 0; i < element.getAlias().size(); i++) { 16540 composeString(t, "Organization", "alias", element.getAlias().get(i), i); 16541 } 16542 for (int i = 0; i < element.getTelecom().size(); i++) { 16543 composeContactPoint(t, "Organization", "telecom", element.getTelecom().get(i), i); 16544 } 16545 for (int i = 0; i < element.getAddress().size(); i++) { 16546 composeAddress(t, "Organization", "address", element.getAddress().get(i), i); 16547 } 16548 if (element.hasPartOf()) { 16549 composeReference(t, "Organization", "partOf", element.getPartOf(), -1); 16550 } 16551 for (int i = 0; i < element.getContact().size(); i++) { 16552 composeOrganizationContactComponent(t, "Organization", "contact", element.getContact().get(i), i); 16553 } 16554 for (int i = 0; i < element.getEndpoint().size(); i++) { 16555 composeReference(t, "Organization", "endpoint", element.getEndpoint().get(i), i); 16556 } 16557 } 16558 16559 protected void composeOrganizationContactComponent(Complex parent, String parentType, String name, Organization.OrganizationContactComponent element, int index) { 16560 if (element == null) 16561 return; 16562 Complex t; 16563 if (Utilities.noString(parentType)) 16564 t = parent; 16565 else { 16566 t = parent.predicate("fhir:"+parentType+'.'+name); 16567 } 16568 composeBackboneElement(t, "contact", name, element, index); 16569 if (element.hasPurpose()) { 16570 composeCodeableConcept(t, "OrganizationContactComponent", "purpose", element.getPurpose(), -1); 16571 } 16572 if (element.hasName()) { 16573 composeHumanName(t, "OrganizationContactComponent", "name", element.getName(), -1); 16574 } 16575 for (int i = 0; i < element.getTelecom().size(); i++) { 16576 composeContactPoint(t, "OrganizationContactComponent", "telecom", element.getTelecom().get(i), i); 16577 } 16578 if (element.hasAddress()) { 16579 composeAddress(t, "OrganizationContactComponent", "address", element.getAddress(), -1); 16580 } 16581 } 16582 16583 protected void composeOrganizationAffiliation(Complex parent, String parentType, String name, OrganizationAffiliation element, int index) { 16584 if (element == null) 16585 return; 16586 Complex t; 16587 if (Utilities.noString(parentType)) 16588 t = parent; 16589 else { 16590 t = parent.predicate("fhir:"+parentType+'.'+name); 16591 } 16592 composeDomainResource(t, "OrganizationAffiliation", name, element, index); 16593 for (int i = 0; i < element.getIdentifier().size(); i++) { 16594 composeIdentifier(t, "OrganizationAffiliation", "identifier", element.getIdentifier().get(i), i); 16595 } 16596 if (element.hasActiveElement()) { 16597 composeBoolean(t, "OrganizationAffiliation", "active", element.getActiveElement(), -1); 16598 } 16599 if (element.hasPeriod()) { 16600 composePeriod(t, "OrganizationAffiliation", "period", element.getPeriod(), -1); 16601 } 16602 if (element.hasOrganization()) { 16603 composeReference(t, "OrganizationAffiliation", "organization", element.getOrganization(), -1); 16604 } 16605 if (element.hasParticipatingOrganization()) { 16606 composeReference(t, "OrganizationAffiliation", "participatingOrganization", element.getParticipatingOrganization(), -1); 16607 } 16608 for (int i = 0; i < element.getNetwork().size(); i++) { 16609 composeReference(t, "OrganizationAffiliation", "network", element.getNetwork().get(i), i); 16610 } 16611 for (int i = 0; i < element.getCode().size(); i++) { 16612 composeCodeableConcept(t, "OrganizationAffiliation", "code", element.getCode().get(i), i); 16613 } 16614 for (int i = 0; i < element.getSpecialty().size(); i++) { 16615 composeCodeableConcept(t, "OrganizationAffiliation", "specialty", element.getSpecialty().get(i), i); 16616 } 16617 for (int i = 0; i < element.getLocation().size(); i++) { 16618 composeReference(t, "OrganizationAffiliation", "location", element.getLocation().get(i), i); 16619 } 16620 for (int i = 0; i < element.getHealthcareService().size(); i++) { 16621 composeReference(t, "OrganizationAffiliation", "healthcareService", element.getHealthcareService().get(i), i); 16622 } 16623 for (int i = 0; i < element.getTelecom().size(); i++) { 16624 composeContactPoint(t, "OrganizationAffiliation", "telecom", element.getTelecom().get(i), i); 16625 } 16626 for (int i = 0; i < element.getEndpoint().size(); i++) { 16627 composeReference(t, "OrganizationAffiliation", "endpoint", element.getEndpoint().get(i), i); 16628 } 16629 } 16630 16631 protected void composePackagedProductDefinition(Complex parent, String parentType, String name, PackagedProductDefinition element, int index) { 16632 if (element == null) 16633 return; 16634 Complex t; 16635 if (Utilities.noString(parentType)) 16636 t = parent; 16637 else { 16638 t = parent.predicate("fhir:"+parentType+'.'+name); 16639 } 16640 composeDomainResource(t, "PackagedProductDefinition", name, element, index); 16641 for (int i = 0; i < element.getIdentifier().size(); i++) { 16642 composeIdentifier(t, "PackagedProductDefinition", "identifier", element.getIdentifier().get(i), i); 16643 } 16644 for (int i = 0; i < element.getSubject().size(); i++) { 16645 composeReference(t, "PackagedProductDefinition", "subject", element.getSubject().get(i), i); 16646 } 16647 if (element.hasDescriptionElement()) { 16648 composeString(t, "PackagedProductDefinition", "description", element.getDescriptionElement(), -1); 16649 } 16650 if (element.hasLegalStatusOfSupply()) { 16651 composeCodeableConcept(t, "PackagedProductDefinition", "legalStatusOfSupply", element.getLegalStatusOfSupply(), -1); 16652 } 16653 for (int i = 0; i < element.getMarketingStatus().size(); i++) { 16654 composeMarketingStatus(t, "PackagedProductDefinition", "marketingStatus", element.getMarketingStatus().get(i), i); 16655 } 16656 if (element.hasCopackagedIndicatorElement()) { 16657 composeBoolean(t, "PackagedProductDefinition", "copackagedIndicator", element.getCopackagedIndicatorElement(), -1); 16658 } 16659 if (element.hasMarketingAuthorization()) { 16660 composeReference(t, "PackagedProductDefinition", "marketingAuthorization", element.getMarketingAuthorization(), -1); 16661 } 16662 for (int i = 0; i < element.getManufacturer().size(); i++) { 16663 composeReference(t, "PackagedProductDefinition", "manufacturer", element.getManufacturer().get(i), i); 16664 } 16665 for (int i = 0; i < element.getBatchIdentifier().size(); i++) { 16666 composePackagedProductDefinitionBatchIdentifierComponent(t, "PackagedProductDefinition", "batchIdentifier", element.getBatchIdentifier().get(i), i); 16667 } 16668 for (int i = 0; i < element.getPackage().size(); i++) { 16669 composePackagedProductDefinitionPackageComponent(t, "PackagedProductDefinition", "package", element.getPackage().get(i), i); 16670 } 16671 } 16672 16673 protected void composePackagedProductDefinitionBatchIdentifierComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionBatchIdentifierComponent element, int index) { 16674 if (element == null) 16675 return; 16676 Complex t; 16677 if (Utilities.noString(parentType)) 16678 t = parent; 16679 else { 16680 t = parent.predicate("fhir:"+parentType+'.'+name); 16681 } 16682 composeBackboneElement(t, "batchIdentifier", name, element, index); 16683 if (element.hasOuterPackaging()) { 16684 composeIdentifier(t, "PackagedProductDefinitionBatchIdentifierComponent", "outerPackaging", element.getOuterPackaging(), -1); 16685 } 16686 if (element.hasImmediatePackaging()) { 16687 composeIdentifier(t, "PackagedProductDefinitionBatchIdentifierComponent", "immediatePackaging", element.getImmediatePackaging(), -1); 16688 } 16689 } 16690 16691 protected void composePackagedProductDefinitionPackageComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionPackageComponent element, int index) { 16692 if (element == null) 16693 return; 16694 Complex t; 16695 if (Utilities.noString(parentType)) 16696 t = parent; 16697 else { 16698 t = parent.predicate("fhir:"+parentType+'.'+name); 16699 } 16700 composeBackboneElement(t, "package", name, element, index); 16701 for (int i = 0; i < element.getIdentifier().size(); i++) { 16702 composeIdentifier(t, "PackagedProductDefinitionPackageComponent", "identifier", element.getIdentifier().get(i), i); 16703 } 16704 if (element.hasType()) { 16705 composeCodeableConcept(t, "PackagedProductDefinitionPackageComponent", "type", element.getType(), -1); 16706 } 16707 if (element.hasQuantity()) { 16708 composeQuantity(t, "PackagedProductDefinitionPackageComponent", "quantity", element.getQuantity(), -1); 16709 } 16710 for (int i = 0; i < element.getMaterial().size(); i++) { 16711 composeCodeableConcept(t, "PackagedProductDefinitionPackageComponent", "material", element.getMaterial().get(i), i); 16712 } 16713 for (int i = 0; i < element.getAlternateMaterial().size(); i++) { 16714 composeCodeableConcept(t, "PackagedProductDefinitionPackageComponent", "alternateMaterial", element.getAlternateMaterial().get(i), i); 16715 } 16716 for (int i = 0; i < element.getShelfLifeStorage().size(); i++) { 16717 composeProductShelfLife(t, "PackagedProductDefinitionPackageComponent", "shelfLifeStorage", element.getShelfLifeStorage().get(i), i); 16718 } 16719 for (int i = 0; i < element.getManufacturer().size(); i++) { 16720 composeReference(t, "PackagedProductDefinitionPackageComponent", "manufacturer", element.getManufacturer().get(i), i); 16721 } 16722 for (int i = 0; i < element.getCharacteristic().size(); i++) { 16723 composePackagedProductDefinitionPackageCharacteristicComponent(t, "PackagedProductDefinitionPackageComponent", "characteristic", element.getCharacteristic().get(i), i); 16724 } 16725 for (int i = 0; i < element.getContainedItem().size(); i++) { 16726 composePackagedProductDefinitionPackageContainedItemComponent(t, "PackagedProductDefinitionPackageComponent", "containedItem", element.getContainedItem().get(i), i); 16727 } 16728 for (int i = 0; i < element.getPackage().size(); i++) { 16729 composePackagedProductDefinitionPackageComponent(t, "PackagedProductDefinitionPackageComponent", "package", element.getPackage().get(i), i); 16730 } 16731 } 16732 16733 protected void composePackagedProductDefinitionPackageCharacteristicComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionPackageCharacteristicComponent element, int index) { 16734 if (element == null) 16735 return; 16736 Complex t; 16737 if (Utilities.noString(parentType)) 16738 t = parent; 16739 else { 16740 t = parent.predicate("fhir:"+parentType+'.'+name); 16741 } 16742 composeBackboneElement(t, "characteristic", name, element, index); 16743 if (element.hasCode()) { 16744 composeCodeableConcept(t, "PackagedProductDefinitionPackageCharacteristicComponent", "code", element.getCode(), -1); 16745 } 16746 if (element.hasValue()) { 16747 composeType(t, "PackagedProductDefinitionPackageCharacteristicComponent", "value", element.getValue(), -1); 16748 } 16749 } 16750 16751 protected void composePackagedProductDefinitionPackageContainedItemComponent(Complex parent, String parentType, String name, PackagedProductDefinition.PackagedProductDefinitionPackageContainedItemComponent element, int index) { 16752 if (element == null) 16753 return; 16754 Complex t; 16755 if (Utilities.noString(parentType)) 16756 t = parent; 16757 else { 16758 t = parent.predicate("fhir:"+parentType+'.'+name); 16759 } 16760 composeBackboneElement(t, "containedItem", name, element, index); 16761 for (int i = 0; i < element.getItem().size(); i++) { 16762 composeReference(t, "PackagedProductDefinitionPackageContainedItemComponent", "item", element.getItem().get(i), i); 16763 } 16764 if (element.hasAmount()) { 16765 composeType(t, "PackagedProductDefinitionPackageContainedItemComponent", "amount", element.getAmount(), -1); 16766 } 16767 } 16768 16769 protected void composeParameters(Complex parent, String parentType, String name, Parameters element, int index) { 16770 if (element == null) 16771 return; 16772 Complex t; 16773 if (Utilities.noString(parentType)) 16774 t = parent; 16775 else { 16776 t = parent.predicate("fhir:"+parentType+'.'+name); 16777 } 16778 composeResource(t, "Parameters", name, element, index); 16779 for (int i = 0; i < element.getParameter().size(); i++) { 16780 composeParametersParameterComponent(t, "Parameters", "parameter", element.getParameter().get(i), i); 16781 } 16782 } 16783 16784 protected void composeParametersParameterComponent(Complex parent, String parentType, String name, Parameters.ParametersParameterComponent element, int index) { 16785 if (element == null) 16786 return; 16787 Complex t; 16788 if (Utilities.noString(parentType)) 16789 t = parent; 16790 else { 16791 t = parent.predicate("fhir:"+parentType+'.'+name); 16792 } 16793 composeBackboneElement(t, "parameter", name, element, index); 16794 if (element.hasNameElement()) { 16795 composeString(t, "ParametersParameterComponent", "name", element.getNameElement(), -1); 16796 } 16797 if (element.hasValue()) { 16798 composeType(t, "ParametersParameterComponent", "value", element.getValue(), -1); 16799 } 16800 if (element.hasResource()) { 16801 composeResource(t, "ParametersParameterComponent", "resource", element.getResource(), -1); 16802 } 16803 for (int i = 0; i < element.getPart().size(); i++) { 16804 composeParametersParameterComponent(t, "ParametersParameterComponent", "part", element.getPart().get(i), i); 16805 } 16806 } 16807 16808 protected void composePatient(Complex parent, String parentType, String name, Patient element, int index) { 16809 if (element == null) 16810 return; 16811 Complex t; 16812 if (Utilities.noString(parentType)) 16813 t = parent; 16814 else { 16815 t = parent.predicate("fhir:"+parentType+'.'+name); 16816 } 16817 composeDomainResource(t, "Patient", name, element, index); 16818 for (int i = 0; i < element.getIdentifier().size(); i++) { 16819 composeIdentifier(t, "Patient", "identifier", element.getIdentifier().get(i), i); 16820 } 16821 if (element.hasActiveElement()) { 16822 composeBoolean(t, "Patient", "active", element.getActiveElement(), -1); 16823 } 16824 for (int i = 0; i < element.getName().size(); i++) { 16825 composeHumanName(t, "Patient", "name", element.getName().get(i), i); 16826 } 16827 for (int i = 0; i < element.getTelecom().size(); i++) { 16828 composeContactPoint(t, "Patient", "telecom", element.getTelecom().get(i), i); 16829 } 16830 if (element.hasGenderElement()) { 16831 composeEnum(t, "Patient", "gender", element.getGenderElement(), -1); 16832 } 16833 if (element.hasBirthDateElement()) { 16834 composeDate(t, "Patient", "birthDate", element.getBirthDateElement(), -1); 16835 } 16836 if (element.hasDeceased()) { 16837 composeType(t, "Patient", "deceased", element.getDeceased(), -1); 16838 } 16839 for (int i = 0; i < element.getAddress().size(); i++) { 16840 composeAddress(t, "Patient", "address", element.getAddress().get(i), i); 16841 } 16842 if (element.hasMaritalStatus()) { 16843 composeCodeableConcept(t, "Patient", "maritalStatus", element.getMaritalStatus(), -1); 16844 } 16845 if (element.hasMultipleBirth()) { 16846 composeType(t, "Patient", "multipleBirth", element.getMultipleBirth(), -1); 16847 } 16848 for (int i = 0; i < element.getPhoto().size(); i++) { 16849 composeAttachment(t, "Patient", "photo", element.getPhoto().get(i), i); 16850 } 16851 for (int i = 0; i < element.getContact().size(); i++) { 16852 composePatientContactComponent(t, "Patient", "contact", element.getContact().get(i), i); 16853 } 16854 for (int i = 0; i < element.getCommunication().size(); i++) { 16855 composePatientCommunicationComponent(t, "Patient", "communication", element.getCommunication().get(i), i); 16856 } 16857 for (int i = 0; i < element.getGeneralPractitioner().size(); i++) { 16858 composeReference(t, "Patient", "generalPractitioner", element.getGeneralPractitioner().get(i), i); 16859 } 16860 if (element.hasManagingOrganization()) { 16861 composeReference(t, "Patient", "managingOrganization", element.getManagingOrganization(), -1); 16862 } 16863 for (int i = 0; i < element.getLink().size(); i++) { 16864 composePatientLinkComponent(t, "Patient", "link", element.getLink().get(i), i); 16865 } 16866 } 16867 16868 protected void composePatientContactComponent(Complex parent, String parentType, String name, Patient.ContactComponent element, int index) { 16869 if (element == null) 16870 return; 16871 Complex t; 16872 if (Utilities.noString(parentType)) 16873 t = parent; 16874 else { 16875 t = parent.predicate("fhir:"+parentType+'.'+name); 16876 } 16877 composeBackboneElement(t, "contact", name, element, index); 16878 for (int i = 0; i < element.getRelationship().size(); i++) { 16879 composeCodeableConcept(t, "ContactComponent", "relationship", element.getRelationship().get(i), i); 16880 } 16881 if (element.hasName()) { 16882 composeHumanName(t, "ContactComponent", "name", element.getName(), -1); 16883 } 16884 for (int i = 0; i < element.getTelecom().size(); i++) { 16885 composeContactPoint(t, "ContactComponent", "telecom", element.getTelecom().get(i), i); 16886 } 16887 if (element.hasAddress()) { 16888 composeAddress(t, "ContactComponent", "address", element.getAddress(), -1); 16889 } 16890 if (element.hasGenderElement()) { 16891 composeEnum(t, "ContactComponent", "gender", element.getGenderElement(), -1); 16892 } 16893 if (element.hasOrganization()) { 16894 composeReference(t, "ContactComponent", "organization", element.getOrganization(), -1); 16895 } 16896 if (element.hasPeriod()) { 16897 composePeriod(t, "ContactComponent", "period", element.getPeriod(), -1); 16898 } 16899 } 16900 16901 protected void composePatientCommunicationComponent(Complex parent, String parentType, String name, Patient.PatientCommunicationComponent element, int index) { 16902 if (element == null) 16903 return; 16904 Complex t; 16905 if (Utilities.noString(parentType)) 16906 t = parent; 16907 else { 16908 t = parent.predicate("fhir:"+parentType+'.'+name); 16909 } 16910 composeBackboneElement(t, "communication", name, element, index); 16911 if (element.hasLanguage()) { 16912 composeCodeableConcept(t, "PatientCommunicationComponent", "language", element.getLanguage(), -1); 16913 } 16914 if (element.hasPreferredElement()) { 16915 composeBoolean(t, "PatientCommunicationComponent", "preferred", element.getPreferredElement(), -1); 16916 } 16917 } 16918 16919 protected void composePatientLinkComponent(Complex parent, String parentType, String name, Patient.PatientLinkComponent element, int index) { 16920 if (element == null) 16921 return; 16922 Complex t; 16923 if (Utilities.noString(parentType)) 16924 t = parent; 16925 else { 16926 t = parent.predicate("fhir:"+parentType+'.'+name); 16927 } 16928 composeBackboneElement(t, "link", name, element, index); 16929 if (element.hasOther()) { 16930 composeReference(t, "PatientLinkComponent", "other", element.getOther(), -1); 16931 } 16932 if (element.hasTypeElement()) { 16933 composeEnum(t, "PatientLinkComponent", "type", element.getTypeElement(), -1); 16934 } 16935 } 16936 16937 protected void composePaymentNotice(Complex parent, String parentType, String name, PaymentNotice element, int index) { 16938 if (element == null) 16939 return; 16940 Complex t; 16941 if (Utilities.noString(parentType)) 16942 t = parent; 16943 else { 16944 t = parent.predicate("fhir:"+parentType+'.'+name); 16945 } 16946 composeDomainResource(t, "PaymentNotice", name, element, index); 16947 for (int i = 0; i < element.getIdentifier().size(); i++) { 16948 composeIdentifier(t, "PaymentNotice", "identifier", element.getIdentifier().get(i), i); 16949 } 16950 if (element.hasStatusElement()) { 16951 composeEnum(t, "PaymentNotice", "status", element.getStatusElement(), -1); 16952 } 16953 if (element.hasRequest()) { 16954 composeReference(t, "PaymentNotice", "request", element.getRequest(), -1); 16955 } 16956 if (element.hasResponse()) { 16957 composeReference(t, "PaymentNotice", "response", element.getResponse(), -1); 16958 } 16959 if (element.hasCreatedElement()) { 16960 composeDateTime(t, "PaymentNotice", "created", element.getCreatedElement(), -1); 16961 } 16962 if (element.hasProvider()) { 16963 composeReference(t, "PaymentNotice", "provider", element.getProvider(), -1); 16964 } 16965 if (element.hasPayment()) { 16966 composeReference(t, "PaymentNotice", "payment", element.getPayment(), -1); 16967 } 16968 if (element.hasPaymentDateElement()) { 16969 composeDate(t, "PaymentNotice", "paymentDate", element.getPaymentDateElement(), -1); 16970 } 16971 if (element.hasPayee()) { 16972 composeReference(t, "PaymentNotice", "payee", element.getPayee(), -1); 16973 } 16974 if (element.hasRecipient()) { 16975 composeReference(t, "PaymentNotice", "recipient", element.getRecipient(), -1); 16976 } 16977 if (element.hasAmount()) { 16978 composeMoney(t, "PaymentNotice", "amount", element.getAmount(), -1); 16979 } 16980 if (element.hasPaymentStatus()) { 16981 composeCodeableConcept(t, "PaymentNotice", "paymentStatus", element.getPaymentStatus(), -1); 16982 } 16983 } 16984 16985 protected void composePaymentReconciliation(Complex parent, String parentType, String name, PaymentReconciliation element, int index) { 16986 if (element == null) 16987 return; 16988 Complex t; 16989 if (Utilities.noString(parentType)) 16990 t = parent; 16991 else { 16992 t = parent.predicate("fhir:"+parentType+'.'+name); 16993 } 16994 composeDomainResource(t, "PaymentReconciliation", name, element, index); 16995 for (int i = 0; i < element.getIdentifier().size(); i++) { 16996 composeIdentifier(t, "PaymentReconciliation", "identifier", element.getIdentifier().get(i), i); 16997 } 16998 if (element.hasStatusElement()) { 16999 composeEnum(t, "PaymentReconciliation", "status", element.getStatusElement(), -1); 17000 } 17001 if (element.hasPeriod()) { 17002 composePeriod(t, "PaymentReconciliation", "period", element.getPeriod(), -1); 17003 } 17004 if (element.hasCreatedElement()) { 17005 composeDateTime(t, "PaymentReconciliation", "created", element.getCreatedElement(), -1); 17006 } 17007 if (element.hasPaymentIssuer()) { 17008 composeReference(t, "PaymentReconciliation", "paymentIssuer", element.getPaymentIssuer(), -1); 17009 } 17010 if (element.hasRequest()) { 17011 composeReference(t, "PaymentReconciliation", "request", element.getRequest(), -1); 17012 } 17013 if (element.hasRequestor()) { 17014 composeReference(t, "PaymentReconciliation", "requestor", element.getRequestor(), -1); 17015 } 17016 if (element.hasOutcomeElement()) { 17017 composeEnum(t, "PaymentReconciliation", "outcome", element.getOutcomeElement(), -1); 17018 } 17019 if (element.hasDispositionElement()) { 17020 composeString(t, "PaymentReconciliation", "disposition", element.getDispositionElement(), -1); 17021 } 17022 if (element.hasPaymentDateElement()) { 17023 composeDate(t, "PaymentReconciliation", "paymentDate", element.getPaymentDateElement(), -1); 17024 } 17025 if (element.hasPaymentAmount()) { 17026 composeMoney(t, "PaymentReconciliation", "paymentAmount", element.getPaymentAmount(), -1); 17027 } 17028 if (element.hasPaymentIdentifier()) { 17029 composeIdentifier(t, "PaymentReconciliation", "paymentIdentifier", element.getPaymentIdentifier(), -1); 17030 } 17031 for (int i = 0; i < element.getDetail().size(); i++) { 17032 composePaymentReconciliationDetailsComponent(t, "PaymentReconciliation", "detail", element.getDetail().get(i), i); 17033 } 17034 if (element.hasFormCode()) { 17035 composeCodeableConcept(t, "PaymentReconciliation", "formCode", element.getFormCode(), -1); 17036 } 17037 for (int i = 0; i < element.getProcessNote().size(); i++) { 17038 composePaymentReconciliationNotesComponent(t, "PaymentReconciliation", "processNote", element.getProcessNote().get(i), i); 17039 } 17040 } 17041 17042 protected void composePaymentReconciliationDetailsComponent(Complex parent, String parentType, String name, PaymentReconciliation.DetailsComponent element, int index) { 17043 if (element == null) 17044 return; 17045 Complex t; 17046 if (Utilities.noString(parentType)) 17047 t = parent; 17048 else { 17049 t = parent.predicate("fhir:"+parentType+'.'+name); 17050 } 17051 composeBackboneElement(t, "detail", name, element, index); 17052 if (element.hasIdentifier()) { 17053 composeIdentifier(t, "DetailsComponent", "identifier", element.getIdentifier(), -1); 17054 } 17055 if (element.hasPredecessor()) { 17056 composeIdentifier(t, "DetailsComponent", "predecessor", element.getPredecessor(), -1); 17057 } 17058 if (element.hasType()) { 17059 composeCodeableConcept(t, "DetailsComponent", "type", element.getType(), -1); 17060 } 17061 if (element.hasRequest()) { 17062 composeReference(t, "DetailsComponent", "request", element.getRequest(), -1); 17063 } 17064 if (element.hasSubmitter()) { 17065 composeReference(t, "DetailsComponent", "submitter", element.getSubmitter(), -1); 17066 } 17067 if (element.hasResponse()) { 17068 composeReference(t, "DetailsComponent", "response", element.getResponse(), -1); 17069 } 17070 if (element.hasDateElement()) { 17071 composeDate(t, "DetailsComponent", "date", element.getDateElement(), -1); 17072 } 17073 if (element.hasResponsible()) { 17074 composeReference(t, "DetailsComponent", "responsible", element.getResponsible(), -1); 17075 } 17076 if (element.hasPayee()) { 17077 composeReference(t, "DetailsComponent", "payee", element.getPayee(), -1); 17078 } 17079 if (element.hasAmount()) { 17080 composeMoney(t, "DetailsComponent", "amount", element.getAmount(), -1); 17081 } 17082 } 17083 17084 protected void composePaymentReconciliationNotesComponent(Complex parent, String parentType, String name, PaymentReconciliation.NotesComponent element, int index) { 17085 if (element == null) 17086 return; 17087 Complex t; 17088 if (Utilities.noString(parentType)) 17089 t = parent; 17090 else { 17091 t = parent.predicate("fhir:"+parentType+'.'+name); 17092 } 17093 composeBackboneElement(t, "processNote", name, element, index); 17094 if (element.hasTypeElement()) { 17095 composeEnum(t, "NotesComponent", "type", element.getTypeElement(), -1); 17096 } 17097 if (element.hasTextElement()) { 17098 composeString(t, "NotesComponent", "text", element.getTextElement(), -1); 17099 } 17100 } 17101 17102 protected void composePerson(Complex parent, String parentType, String name, Person element, int index) { 17103 if (element == null) 17104 return; 17105 Complex t; 17106 if (Utilities.noString(parentType)) 17107 t = parent; 17108 else { 17109 t = parent.predicate("fhir:"+parentType+'.'+name); 17110 } 17111 composeDomainResource(t, "Person", name, element, index); 17112 for (int i = 0; i < element.getIdentifier().size(); i++) { 17113 composeIdentifier(t, "Person", "identifier", element.getIdentifier().get(i), i); 17114 } 17115 for (int i = 0; i < element.getName().size(); i++) { 17116 composeHumanName(t, "Person", "name", element.getName().get(i), i); 17117 } 17118 for (int i = 0; i < element.getTelecom().size(); i++) { 17119 composeContactPoint(t, "Person", "telecom", element.getTelecom().get(i), i); 17120 } 17121 if (element.hasGenderElement()) { 17122 composeEnum(t, "Person", "gender", element.getGenderElement(), -1); 17123 } 17124 if (element.hasBirthDateElement()) { 17125 composeDate(t, "Person", "birthDate", element.getBirthDateElement(), -1); 17126 } 17127 for (int i = 0; i < element.getAddress().size(); i++) { 17128 composeAddress(t, "Person", "address", element.getAddress().get(i), i); 17129 } 17130 if (element.hasPhoto()) { 17131 composeAttachment(t, "Person", "photo", element.getPhoto(), -1); 17132 } 17133 if (element.hasManagingOrganization()) { 17134 composeReference(t, "Person", "managingOrganization", element.getManagingOrganization(), -1); 17135 } 17136 if (element.hasActiveElement()) { 17137 composeBoolean(t, "Person", "active", element.getActiveElement(), -1); 17138 } 17139 for (int i = 0; i < element.getLink().size(); i++) { 17140 composePersonLinkComponent(t, "Person", "link", element.getLink().get(i), i); 17141 } 17142 } 17143 17144 protected void composePersonLinkComponent(Complex parent, String parentType, String name, Person.PersonLinkComponent 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, "link", name, element, index); 17154 if (element.hasTarget()) { 17155 composeReference(t, "PersonLinkComponent", "target", element.getTarget(), -1); 17156 } 17157 if (element.hasAssuranceElement()) { 17158 composeEnum(t, "PersonLinkComponent", "assurance", element.getAssuranceElement(), -1); 17159 } 17160 } 17161 17162 protected void composePlanDefinition(Complex parent, String parentType, String name, PlanDefinition 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 composeMetadataResource(t, "PlanDefinition", name, element, index); 17172 if (element.hasUrlElement()) { 17173 composeUri(t, "PlanDefinition", "url", element.getUrlElement(), -1); 17174 } 17175 for (int i = 0; i < element.getIdentifier().size(); i++) { 17176 composeIdentifier(t, "PlanDefinition", "identifier", element.getIdentifier().get(i), i); 17177 } 17178 if (element.hasVersionElement()) { 17179 composeString(t, "PlanDefinition", "version", element.getVersionElement(), -1); 17180 } 17181 if (element.hasNameElement()) { 17182 composeString(t, "PlanDefinition", "name", element.getNameElement(), -1); 17183 } 17184 if (element.hasTitleElement()) { 17185 composeString(t, "PlanDefinition", "title", element.getTitleElement(), -1); 17186 } 17187 if (element.hasSubtitleElement()) { 17188 composeString(t, "PlanDefinition", "subtitle", element.getSubtitleElement(), -1); 17189 } 17190 if (element.hasType()) { 17191 composeCodeableConcept(t, "PlanDefinition", "type", element.getType(), -1); 17192 } 17193 if (element.hasStatusElement()) { 17194 composeEnum(t, "PlanDefinition", "status", element.getStatusElement(), -1); 17195 } 17196 if (element.hasExperimentalElement()) { 17197 composeBoolean(t, "PlanDefinition", "experimental", element.getExperimentalElement(), -1); 17198 } 17199 if (element.hasSubject()) { 17200 composeType(t, "PlanDefinition", "subject", element.getSubject(), -1); 17201 } 17202 if (element.hasDateElement()) { 17203 composeDateTime(t, "PlanDefinition", "date", element.getDateElement(), -1); 17204 } 17205 if (element.hasPublisherElement()) { 17206 composeString(t, "PlanDefinition", "publisher", element.getPublisherElement(), -1); 17207 } 17208 for (int i = 0; i < element.getContact().size(); i++) { 17209 composeContactDetail(t, "PlanDefinition", "contact", element.getContact().get(i), i); 17210 } 17211 if (element.hasDescriptionElement()) { 17212 composeMarkdown(t, "PlanDefinition", "description", element.getDescriptionElement(), -1); 17213 } 17214 for (int i = 0; i < element.getUseContext().size(); i++) { 17215 composeUsageContext(t, "PlanDefinition", "useContext", element.getUseContext().get(i), i); 17216 } 17217 for (int i = 0; i < element.getJurisdiction().size(); i++) { 17218 composeCodeableConcept(t, "PlanDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 17219 } 17220 if (element.hasPurposeElement()) { 17221 composeMarkdown(t, "PlanDefinition", "purpose", element.getPurposeElement(), -1); 17222 } 17223 if (element.hasUsageElement()) { 17224 composeString(t, "PlanDefinition", "usage", element.getUsageElement(), -1); 17225 } 17226 if (element.hasCopyrightElement()) { 17227 composeMarkdown(t, "PlanDefinition", "copyright", element.getCopyrightElement(), -1); 17228 } 17229 if (element.hasApprovalDateElement()) { 17230 composeDate(t, "PlanDefinition", "approvalDate", element.getApprovalDateElement(), -1); 17231 } 17232 if (element.hasLastReviewDateElement()) { 17233 composeDate(t, "PlanDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 17234 } 17235 if (element.hasEffectivePeriod()) { 17236 composePeriod(t, "PlanDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 17237 } 17238 for (int i = 0; i < element.getTopic().size(); i++) { 17239 composeCodeableConcept(t, "PlanDefinition", "topic", element.getTopic().get(i), i); 17240 } 17241 for (int i = 0; i < element.getAuthor().size(); i++) { 17242 composeContactDetail(t, "PlanDefinition", "author", element.getAuthor().get(i), i); 17243 } 17244 for (int i = 0; i < element.getEditor().size(); i++) { 17245 composeContactDetail(t, "PlanDefinition", "editor", element.getEditor().get(i), i); 17246 } 17247 for (int i = 0; i < element.getReviewer().size(); i++) { 17248 composeContactDetail(t, "PlanDefinition", "reviewer", element.getReviewer().get(i), i); 17249 } 17250 for (int i = 0; i < element.getEndorser().size(); i++) { 17251 composeContactDetail(t, "PlanDefinition", "endorser", element.getEndorser().get(i), i); 17252 } 17253 for (int i = 0; i < element.getRelatedArtifact().size(); i++) { 17254 composeRelatedArtifact(t, "PlanDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 17255 } 17256 for (int i = 0; i < element.getLibrary().size(); i++) { 17257 composeCanonical(t, "PlanDefinition", "library", element.getLibrary().get(i), i); 17258 } 17259 for (int i = 0; i < element.getGoal().size(); i++) { 17260 composePlanDefinitionGoalComponent(t, "PlanDefinition", "goal", element.getGoal().get(i), i); 17261 } 17262 for (int i = 0; i < element.getAction().size(); i++) { 17263 composePlanDefinitionActionComponent(t, "PlanDefinition", "action", element.getAction().get(i), i); 17264 } 17265 } 17266 17267 protected void composePlanDefinitionGoalComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionGoalComponent element, int index) { 17268 if (element == null) 17269 return; 17270 Complex t; 17271 if (Utilities.noString(parentType)) 17272 t = parent; 17273 else { 17274 t = parent.predicate("fhir:"+parentType+'.'+name); 17275 } 17276 composeBackboneElement(t, "goal", name, element, index); 17277 if (element.hasCategory()) { 17278 composeCodeableConcept(t, "PlanDefinitionGoalComponent", "category", element.getCategory(), -1); 17279 } 17280 if (element.hasDescription()) { 17281 composeCodeableConcept(t, "PlanDefinitionGoalComponent", "description", element.getDescription(), -1); 17282 } 17283 if (element.hasPriority()) { 17284 composeCodeableConcept(t, "PlanDefinitionGoalComponent", "priority", element.getPriority(), -1); 17285 } 17286 if (element.hasStart()) { 17287 composeCodeableConcept(t, "PlanDefinitionGoalComponent", "start", element.getStart(), -1); 17288 } 17289 for (int i = 0; i < element.getAddresses().size(); i++) { 17290 composeCodeableConcept(t, "PlanDefinitionGoalComponent", "addresses", element.getAddresses().get(i), i); 17291 } 17292 for (int i = 0; i < element.getDocumentation().size(); i++) { 17293 composeRelatedArtifact(t, "PlanDefinitionGoalComponent", "documentation", element.getDocumentation().get(i), i); 17294 } 17295 for (int i = 0; i < element.getTarget().size(); i++) { 17296 composePlanDefinitionGoalTargetComponent(t, "PlanDefinitionGoalComponent", "target", element.getTarget().get(i), i); 17297 } 17298 } 17299 17300 protected void composePlanDefinitionGoalTargetComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionGoalTargetComponent element, int index) { 17301 if (element == null) 17302 return; 17303 Complex t; 17304 if (Utilities.noString(parentType)) 17305 t = parent; 17306 else { 17307 t = parent.predicate("fhir:"+parentType+'.'+name); 17308 } 17309 composeBackboneElement(t, "target", name, element, index); 17310 if (element.hasMeasure()) { 17311 composeCodeableConcept(t, "PlanDefinitionGoalTargetComponent", "measure", element.getMeasure(), -1); 17312 } 17313 if (element.hasDetail()) { 17314 composeType(t, "PlanDefinitionGoalTargetComponent", "detail", element.getDetail(), -1); 17315 } 17316 if (element.hasDue()) { 17317 composeDuration(t, "PlanDefinitionGoalTargetComponent", "due", element.getDue(), -1); 17318 } 17319 } 17320 17321 protected void composePlanDefinitionActionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionComponent element, int index) { 17322 if (element == null) 17323 return; 17324 Complex t; 17325 if (Utilities.noString(parentType)) 17326 t = parent; 17327 else { 17328 t = parent.predicate("fhir:"+parentType+'.'+name); 17329 } 17330 composeBackboneElement(t, "action", name, element, index); 17331 if (element.hasPrefixElement()) { 17332 composeString(t, "PlanDefinitionActionComponent", "prefix", element.getPrefixElement(), -1); 17333 } 17334 if (element.hasTitleElement()) { 17335 composeString(t, "PlanDefinitionActionComponent", "title", element.getTitleElement(), -1); 17336 } 17337 if (element.hasDescriptionElement()) { 17338 composeString(t, "PlanDefinitionActionComponent", "description", element.getDescriptionElement(), -1); 17339 } 17340 if (element.hasTextEquivalentElement()) { 17341 composeString(t, "PlanDefinitionActionComponent", "textEquivalent", element.getTextEquivalentElement(), -1); 17342 } 17343 if (element.hasPriorityElement()) { 17344 composeEnum(t, "PlanDefinitionActionComponent", "priority", element.getPriorityElement(), -1); 17345 } 17346 for (int i = 0; i < element.getCode().size(); i++) { 17347 composeCodeableConcept(t, "PlanDefinitionActionComponent", "code", element.getCode().get(i), i); 17348 } 17349 for (int i = 0; i < element.getReason().size(); i++) { 17350 composeCodeableConcept(t, "PlanDefinitionActionComponent", "reason", element.getReason().get(i), i); 17351 } 17352 for (int i = 0; i < element.getDocumentation().size(); i++) { 17353 composeRelatedArtifact(t, "PlanDefinitionActionComponent", "documentation", element.getDocumentation().get(i), i); 17354 } 17355 for (int i = 0; i < element.getGoalId().size(); i++) { 17356 composeId(t, "PlanDefinitionActionComponent", "goalId", element.getGoalId().get(i), i); 17357 } 17358 if (element.hasSubject()) { 17359 composeType(t, "PlanDefinitionActionComponent", "subject", element.getSubject(), -1); 17360 } 17361 for (int i = 0; i < element.getTrigger().size(); i++) { 17362 composeTriggerDefinition(t, "PlanDefinitionActionComponent", "trigger", element.getTrigger().get(i), i); 17363 } 17364 for (int i = 0; i < element.getCondition().size(); i++) { 17365 composePlanDefinitionActionConditionComponent(t, "PlanDefinitionActionComponent", "condition", element.getCondition().get(i), i); 17366 } 17367 for (int i = 0; i < element.getInput().size(); i++) { 17368 composeDataRequirement(t, "PlanDefinitionActionComponent", "input", element.getInput().get(i), i); 17369 } 17370 for (int i = 0; i < element.getOutput().size(); i++) { 17371 composeDataRequirement(t, "PlanDefinitionActionComponent", "output", element.getOutput().get(i), i); 17372 } 17373 for (int i = 0; i < element.getRelatedAction().size(); i++) { 17374 composePlanDefinitionActionRelatedActionComponent(t, "PlanDefinitionActionComponent", "relatedAction", element.getRelatedAction().get(i), i); 17375 } 17376 if (element.hasTiming()) { 17377 composeType(t, "PlanDefinitionActionComponent", "timing", element.getTiming(), -1); 17378 } 17379 for (int i = 0; i < element.getParticipant().size(); i++) { 17380 composePlanDefinitionActionParticipantComponent(t, "PlanDefinitionActionComponent", "participant", element.getParticipant().get(i), i); 17381 } 17382 if (element.hasType()) { 17383 composeCodeableConcept(t, "PlanDefinitionActionComponent", "type", element.getType(), -1); 17384 } 17385 if (element.hasGroupingBehaviorElement()) { 17386 composeEnum(t, "PlanDefinitionActionComponent", "groupingBehavior", element.getGroupingBehaviorElement(), -1); 17387 } 17388 if (element.hasSelectionBehaviorElement()) { 17389 composeEnum(t, "PlanDefinitionActionComponent", "selectionBehavior", element.getSelectionBehaviorElement(), -1); 17390 } 17391 if (element.hasRequiredBehaviorElement()) { 17392 composeEnum(t, "PlanDefinitionActionComponent", "requiredBehavior", element.getRequiredBehaviorElement(), -1); 17393 } 17394 if (element.hasPrecheckBehaviorElement()) { 17395 composeEnum(t, "PlanDefinitionActionComponent", "precheckBehavior", element.getPrecheckBehaviorElement(), -1); 17396 } 17397 if (element.hasCardinalityBehaviorElement()) { 17398 composeEnum(t, "PlanDefinitionActionComponent", "cardinalityBehavior", element.getCardinalityBehaviorElement(), -1); 17399 } 17400 if (element.hasDefinition()) { 17401 composeType(t, "PlanDefinitionActionComponent", "definition", element.getDefinition(), -1); 17402 } 17403 if (element.hasTransformElement()) { 17404 composeCanonical(t, "PlanDefinitionActionComponent", "transform", element.getTransformElement(), -1); 17405 } 17406 for (int i = 0; i < element.getDynamicValue().size(); i++) { 17407 composePlanDefinitionActionDynamicValueComponent(t, "PlanDefinitionActionComponent", "dynamicValue", element.getDynamicValue().get(i), i); 17408 } 17409 for (int i = 0; i < element.getAction().size(); i++) { 17410 composePlanDefinitionActionComponent(t, "PlanDefinitionActionComponent", "action", element.getAction().get(i), i); 17411 } 17412 } 17413 17414 protected void composePlanDefinitionActionConditionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionConditionComponent element, int index) { 17415 if (element == null) 17416 return; 17417 Complex t; 17418 if (Utilities.noString(parentType)) 17419 t = parent; 17420 else { 17421 t = parent.predicate("fhir:"+parentType+'.'+name); 17422 } 17423 composeBackboneElement(t, "condition", name, element, index); 17424 if (element.hasKindElement()) { 17425 composeEnum(t, "PlanDefinitionActionConditionComponent", "kind", element.getKindElement(), -1); 17426 } 17427 if (element.hasExpression()) { 17428 composeExpression(t, "PlanDefinitionActionConditionComponent", "expression", element.getExpression(), -1); 17429 } 17430 } 17431 17432 protected void composePlanDefinitionActionRelatedActionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionRelatedActionComponent element, int index) { 17433 if (element == null) 17434 return; 17435 Complex t; 17436 if (Utilities.noString(parentType)) 17437 t = parent; 17438 else { 17439 t = parent.predicate("fhir:"+parentType+'.'+name); 17440 } 17441 composeBackboneElement(t, "relatedAction", name, element, index); 17442 if (element.hasActionIdElement()) { 17443 composeId(t, "PlanDefinitionActionRelatedActionComponent", "actionId", element.getActionIdElement(), -1); 17444 } 17445 if (element.hasRelationshipElement()) { 17446 composeEnum(t, "PlanDefinitionActionRelatedActionComponent", "relationship", element.getRelationshipElement(), -1); 17447 } 17448 if (element.hasOffset()) { 17449 composeType(t, "PlanDefinitionActionRelatedActionComponent", "offset", element.getOffset(), -1); 17450 } 17451 } 17452 17453 protected void composePlanDefinitionActionParticipantComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionParticipantComponent element, int index) { 17454 if (element == null) 17455 return; 17456 Complex t; 17457 if (Utilities.noString(parentType)) 17458 t = parent; 17459 else { 17460 t = parent.predicate("fhir:"+parentType+'.'+name); 17461 } 17462 composeBackboneElement(t, "participant", name, element, index); 17463 if (element.hasTypeElement()) { 17464 composeEnum(t, "PlanDefinitionActionParticipantComponent", "type", element.getTypeElement(), -1); 17465 } 17466 if (element.hasRole()) { 17467 composeCodeableConcept(t, "PlanDefinitionActionParticipantComponent", "role", element.getRole(), -1); 17468 } 17469 } 17470 17471 protected void composePlanDefinitionActionDynamicValueComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionDynamicValueComponent element, int index) { 17472 if (element == null) 17473 return; 17474 Complex t; 17475 if (Utilities.noString(parentType)) 17476 t = parent; 17477 else { 17478 t = parent.predicate("fhir:"+parentType+'.'+name); 17479 } 17480 composeBackboneElement(t, "dynamicValue", name, element, index); 17481 if (element.hasPathElement()) { 17482 composeString(t, "PlanDefinitionActionDynamicValueComponent", "path", element.getPathElement(), -1); 17483 } 17484 if (element.hasExpression()) { 17485 composeExpression(t, "PlanDefinitionActionDynamicValueComponent", "expression", element.getExpression(), -1); 17486 } 17487 } 17488 17489 protected void composePractitioner(Complex parent, String parentType, String name, Practitioner element, int index) { 17490 if (element == null) 17491 return; 17492 Complex t; 17493 if (Utilities.noString(parentType)) 17494 t = parent; 17495 else { 17496 t = parent.predicate("fhir:"+parentType+'.'+name); 17497 } 17498 composeDomainResource(t, "Practitioner", name, element, index); 17499 for (int i = 0; i < element.getIdentifier().size(); i++) { 17500 composeIdentifier(t, "Practitioner", "identifier", element.getIdentifier().get(i), i); 17501 } 17502 if (element.hasActiveElement()) { 17503 composeBoolean(t, "Practitioner", "active", element.getActiveElement(), -1); 17504 } 17505 for (int i = 0; i < element.getName().size(); i++) { 17506 composeHumanName(t, "Practitioner", "name", element.getName().get(i), i); 17507 } 17508 for (int i = 0; i < element.getTelecom().size(); i++) { 17509 composeContactPoint(t, "Practitioner", "telecom", element.getTelecom().get(i), i); 17510 } 17511 for (int i = 0; i < element.getAddress().size(); i++) { 17512 composeAddress(t, "Practitioner", "address", element.getAddress().get(i), i); 17513 } 17514 if (element.hasGenderElement()) { 17515 composeEnum(t, "Practitioner", "gender", element.getGenderElement(), -1); 17516 } 17517 if (element.hasBirthDateElement()) { 17518 composeDate(t, "Practitioner", "birthDate", element.getBirthDateElement(), -1); 17519 } 17520 for (int i = 0; i < element.getPhoto().size(); i++) { 17521 composeAttachment(t, "Practitioner", "photo", element.getPhoto().get(i), i); 17522 } 17523 for (int i = 0; i < element.getQualification().size(); i++) { 17524 composePractitionerQualificationComponent(t, "Practitioner", "qualification", element.getQualification().get(i), i); 17525 } 17526 for (int i = 0; i < element.getCommunication().size(); i++) { 17527 composeCodeableConcept(t, "Practitioner", "communication", element.getCommunication().get(i), i); 17528 } 17529 } 17530 17531 protected void composePractitionerQualificationComponent(Complex parent, String parentType, String name, Practitioner.PractitionerQualificationComponent element, int index) { 17532 if (element == null) 17533 return; 17534 Complex t; 17535 if (Utilities.noString(parentType)) 17536 t = parent; 17537 else { 17538 t = parent.predicate("fhir:"+parentType+'.'+name); 17539 } 17540 composeBackboneElement(t, "qualification", name, element, index); 17541 for (int i = 0; i < element.getIdentifier().size(); i++) { 17542 composeIdentifier(t, "PractitionerQualificationComponent", "identifier", element.getIdentifier().get(i), i); 17543 } 17544 if (element.hasCode()) { 17545 composeCodeableConcept(t, "PractitionerQualificationComponent", "code", element.getCode(), -1); 17546 } 17547 if (element.hasPeriod()) { 17548 composePeriod(t, "PractitionerQualificationComponent", "period", element.getPeriod(), -1); 17549 } 17550 if (element.hasIssuer()) { 17551 composeReference(t, "PractitionerQualificationComponent", "issuer", element.getIssuer(), -1); 17552 } 17553 } 17554 17555 protected void composePractitionerRole(Complex parent, String parentType, String name, PractitionerRole element, int index) { 17556 if (element == null) 17557 return; 17558 Complex t; 17559 if (Utilities.noString(parentType)) 17560 t = parent; 17561 else { 17562 t = parent.predicate("fhir:"+parentType+'.'+name); 17563 } 17564 composeDomainResource(t, "PractitionerRole", name, element, index); 17565 for (int i = 0; i < element.getIdentifier().size(); i++) { 17566 composeIdentifier(t, "PractitionerRole", "identifier", element.getIdentifier().get(i), i); 17567 } 17568 if (element.hasActiveElement()) { 17569 composeBoolean(t, "PractitionerRole", "active", element.getActiveElement(), -1); 17570 } 17571 if (element.hasPeriod()) { 17572 composePeriod(t, "PractitionerRole", "period", element.getPeriod(), -1); 17573 } 17574 if (element.hasPractitioner()) { 17575 composeReference(t, "PractitionerRole", "practitioner", element.getPractitioner(), -1); 17576 } 17577 if (element.hasOrganization()) { 17578 composeReference(t, "PractitionerRole", "organization", element.getOrganization(), -1); 17579 } 17580 for (int i = 0; i < element.getCode().size(); i++) { 17581 composeCodeableConcept(t, "PractitionerRole", "code", element.getCode().get(i), i); 17582 } 17583 for (int i = 0; i < element.getSpecialty().size(); i++) { 17584 composeCodeableConcept(t, "PractitionerRole", "specialty", element.getSpecialty().get(i), i); 17585 } 17586 for (int i = 0; i < element.getLocation().size(); i++) { 17587 composeReference(t, "PractitionerRole", "location", element.getLocation().get(i), i); 17588 } 17589 for (int i = 0; i < element.getHealthcareService().size(); i++) { 17590 composeReference(t, "PractitionerRole", "healthcareService", element.getHealthcareService().get(i), i); 17591 } 17592 for (int i = 0; i < element.getTelecom().size(); i++) { 17593 composeContactPoint(t, "PractitionerRole", "telecom", element.getTelecom().get(i), i); 17594 } 17595 for (int i = 0; i < element.getAvailableTime().size(); i++) { 17596 composePractitionerRoleAvailableTimeComponent(t, "PractitionerRole", "availableTime", element.getAvailableTime().get(i), i); 17597 } 17598 for (int i = 0; i < element.getNotAvailable().size(); i++) { 17599 composePractitionerRoleNotAvailableComponent(t, "PractitionerRole", "notAvailable", element.getNotAvailable().get(i), i); 17600 } 17601 if (element.hasAvailabilityExceptionsElement()) { 17602 composeString(t, "PractitionerRole", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1); 17603 } 17604 for (int i = 0; i < element.getEndpoint().size(); i++) { 17605 composeReference(t, "PractitionerRole", "endpoint", element.getEndpoint().get(i), i); 17606 } 17607 } 17608 17609 protected void composePractitionerRoleAvailableTimeComponent(Complex parent, String parentType, String name, PractitionerRole.PractitionerRoleAvailableTimeComponent element, int index) { 17610 if (element == null) 17611 return; 17612 Complex t; 17613 if (Utilities.noString(parentType)) 17614 t = parent; 17615 else { 17616 t = parent.predicate("fhir:"+parentType+'.'+name); 17617 } 17618 composeBackboneElement(t, "availableTime", name, element, index); 17619 for (int i = 0; i < element.getDaysOfWeek().size(); i++) { 17620 composeEnum(t, "PractitionerRoleAvailableTimeComponent", "daysOfWeek", element.getDaysOfWeek().get(i), i); 17621 } 17622 if (element.hasAllDayElement()) { 17623 composeBoolean(t, "PractitionerRoleAvailableTimeComponent", "allDay", element.getAllDayElement(), -1); 17624 } 17625 if (element.hasAvailableStartTimeElement()) { 17626 composeTime(t, "PractitionerRoleAvailableTimeComponent", "availableStartTime", element.getAvailableStartTimeElement(), -1); 17627 } 17628 if (element.hasAvailableEndTimeElement()) { 17629 composeTime(t, "PractitionerRoleAvailableTimeComponent", "availableEndTime", element.getAvailableEndTimeElement(), -1); 17630 } 17631 } 17632 17633 protected void composePractitionerRoleNotAvailableComponent(Complex parent, String parentType, String name, PractitionerRole.PractitionerRoleNotAvailableComponent element, int index) { 17634 if (element == null) 17635 return; 17636 Complex t; 17637 if (Utilities.noString(parentType)) 17638 t = parent; 17639 else { 17640 t = parent.predicate("fhir:"+parentType+'.'+name); 17641 } 17642 composeBackboneElement(t, "notAvailable", name, element, index); 17643 if (element.hasDescriptionElement()) { 17644 composeString(t, "PractitionerRoleNotAvailableComponent", "description", element.getDescriptionElement(), -1); 17645 } 17646 if (element.hasDuring()) { 17647 composePeriod(t, "PractitionerRoleNotAvailableComponent", "during", element.getDuring(), -1); 17648 } 17649 } 17650 17651 protected void composeProcedure(Complex parent, String parentType, String name, Procedure element, int index) { 17652 if (element == null) 17653 return; 17654 Complex t; 17655 if (Utilities.noString(parentType)) 17656 t = parent; 17657 else { 17658 t = parent.predicate("fhir:"+parentType+'.'+name); 17659 } 17660 composeDomainResource(t, "Procedure", name, element, index); 17661 for (int i = 0; i < element.getIdentifier().size(); i++) { 17662 composeIdentifier(t, "Procedure", "identifier", element.getIdentifier().get(i), i); 17663 } 17664 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) { 17665 composeCanonical(t, "Procedure", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 17666 } 17667 for (int i = 0; i < element.getInstantiatesUri().size(); i++) { 17668 composeUri(t, "Procedure", "instantiatesUri", element.getInstantiatesUri().get(i), i); 17669 } 17670 for (int i = 0; i < element.getBasedOn().size(); i++) { 17671 composeReference(t, "Procedure", "basedOn", element.getBasedOn().get(i), i); 17672 } 17673 for (int i = 0; i < element.getPartOf().size(); i++) { 17674 composeReference(t, "Procedure", "partOf", element.getPartOf().get(i), i); 17675 } 17676 if (element.hasStatusElement()) { 17677 composeEnum(t, "Procedure", "status", element.getStatusElement(), -1); 17678 } 17679 if (element.hasStatusReason()) { 17680 composeCodeableConcept(t, "Procedure", "statusReason", element.getStatusReason(), -1); 17681 } 17682 for (int i = 0; i < element.getCategory().size(); i++) { 17683 composeCodeableConcept(t, "Procedure", "category", element.getCategory().get(i), i); 17684 } 17685 if (element.hasCode()) { 17686 composeCodeableConcept(t, "Procedure", "code", element.getCode(), -1); 17687 } 17688 if (element.hasSubject()) { 17689 composeReference(t, "Procedure", "subject", element.getSubject(), -1); 17690 } 17691 if (element.hasEncounter()) { 17692 composeReference(t, "Procedure", "encounter", element.getEncounter(), -1); 17693 } 17694 if (element.hasOccurrence()) { 17695 composeType(t, "Procedure", "occurrence", element.getOccurrence(), -1); 17696 } 17697 if (element.hasRecordedElement()) { 17698 composeDateTime(t, "Procedure", "recorded", element.getRecordedElement(), -1); 17699 } 17700 if (element.hasRecorder()) { 17701 composeReference(t, "Procedure", "recorder", element.getRecorder(), -1); 17702 } 17703 if (element.hasReported()) { 17704 composeType(t, "Procedure", "reported", element.getReported(), -1); 17705 } 17706 for (int i = 0; i < element.getPerformer().size(); i++) { 17707 composeProcedurePerformerComponent(t, "Procedure", "performer", element.getPerformer().get(i), i); 17708 } 17709 if (element.hasLocation()) { 17710 composeReference(t, "Procedure", "location", element.getLocation(), -1); 17711 } 17712 for (int i = 0; i < element.getReason().size(); i++) { 17713 composeCodeableReference(t, "Procedure", "reason", element.getReason().get(i), i); 17714 } 17715 for (int i = 0; i < element.getBodySite().size(); i++) { 17716 composeCodeableConcept(t, "Procedure", "bodySite", element.getBodySite().get(i), i); 17717 } 17718 if (element.hasOutcome()) { 17719 composeCodeableConcept(t, "Procedure", "outcome", element.getOutcome(), -1); 17720 } 17721 for (int i = 0; i < element.getReport().size(); i++) { 17722 composeReference(t, "Procedure", "report", element.getReport().get(i), i); 17723 } 17724 for (int i = 0; i < element.getComplication().size(); i++) { 17725 composeCodeableConcept(t, "Procedure", "complication", element.getComplication().get(i), i); 17726 } 17727 for (int i = 0; i < element.getComplicationDetail().size(); i++) { 17728 composeReference(t, "Procedure", "complicationDetail", element.getComplicationDetail().get(i), i); 17729 } 17730 for (int i = 0; i < element.getFollowUp().size(); i++) { 17731 composeCodeableConcept(t, "Procedure", "followUp", element.getFollowUp().get(i), i); 17732 } 17733 for (int i = 0; i < element.getNote().size(); i++) { 17734 composeAnnotation(t, "Procedure", "note", element.getNote().get(i), i); 17735 } 17736 for (int i = 0; i < element.getFocalDevice().size(); i++) { 17737 composeProcedureFocalDeviceComponent(t, "Procedure", "focalDevice", element.getFocalDevice().get(i), i); 17738 } 17739 for (int i = 0; i < element.getUsed().size(); i++) { 17740 composeCodeableReference(t, "Procedure", "used", element.getUsed().get(i), i); 17741 } 17742 } 17743 17744 protected void composeProcedurePerformerComponent(Complex parent, String parentType, String name, Procedure.ProcedurePerformerComponent element, int index) { 17745 if (element == null) 17746 return; 17747 Complex t; 17748 if (Utilities.noString(parentType)) 17749 t = parent; 17750 else { 17751 t = parent.predicate("fhir:"+parentType+'.'+name); 17752 } 17753 composeBackboneElement(t, "performer", name, element, index); 17754 if (element.hasFunction()) { 17755 composeCodeableConcept(t, "ProcedurePerformerComponent", "function", element.getFunction(), -1); 17756 } 17757 if (element.hasActor()) { 17758 composeReference(t, "ProcedurePerformerComponent", "actor", element.getActor(), -1); 17759 } 17760 if (element.hasOnBehalfOf()) { 17761 composeReference(t, "ProcedurePerformerComponent", "onBehalfOf", element.getOnBehalfOf(), -1); 17762 } 17763 } 17764 17765 protected void composeProcedureFocalDeviceComponent(Complex parent, String parentType, String name, Procedure.ProcedureFocalDeviceComponent element, int index) { 17766 if (element == null) 17767 return; 17768 Complex t; 17769 if (Utilities.noString(parentType)) 17770 t = parent; 17771 else { 17772 t = parent.predicate("fhir:"+parentType+'.'+name); 17773 } 17774 composeBackboneElement(t, "focalDevice", name, element, index); 17775 if (element.hasAction()) { 17776 composeCodeableConcept(t, "ProcedureFocalDeviceComponent", "action", element.getAction(), -1); 17777 } 17778 if (element.hasManipulated()) { 17779 composeReference(t, "ProcedureFocalDeviceComponent", "manipulated", element.getManipulated(), -1); 17780 } 17781 } 17782 17783 protected void composeProvenance(Complex parent, String parentType, String name, Provenance element, int index) { 17784 if (element == null) 17785 return; 17786 Complex t; 17787 if (Utilities.noString(parentType)) 17788 t = parent; 17789 else { 17790 t = parent.predicate("fhir:"+parentType+'.'+name); 17791 } 17792 composeDomainResource(t, "Provenance", name, element, index); 17793 for (int i = 0; i < element.getTarget().size(); i++) { 17794 composeReference(t, "Provenance", "target", element.getTarget().get(i), i); 17795 } 17796 if (element.hasOccurred()) { 17797 composeType(t, "Provenance", "occurred", element.getOccurred(), -1); 17798 } 17799 if (element.hasRecordedElement()) { 17800 composeInstant(t, "Provenance", "recorded", element.getRecordedElement(), -1); 17801 } 17802 for (int i = 0; i < element.getPolicy().size(); i++) { 17803 composeUri(t, "Provenance", "policy", element.getPolicy().get(i), i); 17804 } 17805 if (element.hasLocation()) { 17806 composeReference(t, "Provenance", "location", element.getLocation(), -1); 17807 } 17808 for (int i = 0; i < element.getReason().size(); i++) { 17809 composeCodeableConcept(t, "Provenance", "reason", element.getReason().get(i), i); 17810 } 17811 if (element.hasActivity()) { 17812 composeCodeableConcept(t, "Provenance", "activity", element.getActivity(), -1); 17813 } 17814 for (int i = 0; i < element.getAgent().size(); i++) { 17815 composeProvenanceAgentComponent(t, "Provenance", "agent", element.getAgent().get(i), i); 17816 } 17817 for (int i = 0; i < element.getEntity().size(); i++) { 17818 composeProvenanceEntityComponent(t, "Provenance", "entity", element.getEntity().get(i), i); 17819 } 17820 for (int i = 0; i < element.getSignature().size(); i++) { 17821 composeSignature(t, "Provenance", "signature", element.getSignature().get(i), i); 17822 } 17823 } 17824 17825 protected void composeProvenanceAgentComponent(Complex parent, String parentType, String name, Provenance.ProvenanceAgentComponent element, int index) { 17826 if (element == null) 17827 return; 17828 Complex t; 17829 if (Utilities.noString(parentType)) 17830 t = parent; 17831 else { 17832 t = parent.predicate("fhir:"+parentType+'.'+name); 17833 } 17834 composeBackboneElement(t, "agent", name, element, index); 17835 if (element.hasType()) { 17836 composeCodeableConcept(t, "ProvenanceAgentComponent", "type", element.getType(), -1); 17837 } 17838 for (int i = 0; i < element.getRole().size(); i++) { 17839 composeCodeableConcept(t, "ProvenanceAgentComponent", "role", element.getRole().get(i), i); 17840 } 17841 if (element.hasWho()) { 17842 composeReference(t, "ProvenanceAgentComponent", "who", element.getWho(), -1); 17843 } 17844 if (element.hasOnBehalfOf()) { 17845 composeReference(t, "ProvenanceAgentComponent", "onBehalfOf", element.getOnBehalfOf(), -1); 17846 } 17847 } 17848 17849 protected void composeProvenanceEntityComponent(Complex parent, String parentType, String name, Provenance.ProvenanceEntityComponent element, int index) { 17850 if (element == null) 17851 return; 17852 Complex t; 17853 if (Utilities.noString(parentType)) 17854 t = parent; 17855 else { 17856 t = parent.predicate("fhir:"+parentType+'.'+name); 17857 } 17858 composeBackboneElement(t, "entity", name, element, index); 17859 if (element.hasRoleElement()) { 17860 composeEnum(t, "ProvenanceEntityComponent", "role", element.getRoleElement(), -1); 17861 } 17862 if (element.hasWhat()) { 17863 composeReference(t, "ProvenanceEntityComponent", "what", element.getWhat(), -1); 17864 } 17865 for (int i = 0; i < element.getAgent().size(); i++) { 17866 composeProvenanceAgentComponent(t, "ProvenanceEntityComponent", "agent", element.getAgent().get(i), i); 17867 } 17868 } 17869 17870 protected void composeQuestionnaire(Complex parent, String parentType, String name, Questionnaire element, int index) { 17871 if (element == null) 17872 return; 17873 Complex t; 17874 if (Utilities.noString(parentType)) 17875 t = parent; 17876 else { 17877 t = parent.predicate("fhir:"+parentType+'.'+name); 17878 } 17879 composeMetadataResource(t, "Questionnaire", name, element, index); 17880 if (element.hasUrlElement()) { 17881 composeUri(t, "Questionnaire", "url", element.getUrlElement(), -1); 17882 } 17883 for (int i = 0; i < element.getIdentifier().size(); i++) { 17884 composeIdentifier(t, "Questionnaire", "identifier", element.getIdentifier().get(i), i); 17885 } 17886 if (element.hasVersionElement()) { 17887 composeString(t, "Questionnaire", "version", element.getVersionElement(), -1); 17888 } 17889 if (element.hasNameElement()) { 17890 composeString(t, "Questionnaire", "name", element.getNameElement(), -1); 17891 } 17892 if (element.hasTitleElement()) { 17893 composeString(t, "Questionnaire", "title", element.getTitleElement(), -1); 17894 } 17895 for (int i = 0; i < element.getDerivedFrom().size(); i++) { 17896 composeCanonical(t, "Questionnaire", "derivedFrom", element.getDerivedFrom().get(i), i); 17897 } 17898 if (element.hasStatusElement()) { 17899 composeEnum(t, "Questionnaire", "status", element.getStatusElement(), -1); 17900 } 17901 if (element.hasExperimentalElement()) { 17902 composeBoolean(t, "Questionnaire", "experimental", element.getExperimentalElement(), -1); 17903 } 17904 for (int i = 0; i < element.getSubjectType().size(); i++) { 17905 composeCode(t, "Questionnaire", "subjectType", element.getSubjectType().get(i), i); 17906 } 17907 if (element.hasDateElement()) { 17908 composeDateTime(t, "Questionnaire", "date", element.getDateElement(), -1); 17909 } 17910 if (element.hasPublisherElement()) { 17911 composeString(t, "Questionnaire", "publisher", element.getPublisherElement(), -1); 17912 } 17913 for (int i = 0; i < element.getContact().size(); i++) { 17914 composeContactDetail(t, "Questionnaire", "contact", element.getContact().get(i), i); 17915 } 17916 if (element.hasDescriptionElement()) { 17917 composeMarkdown(t, "Questionnaire", "description", element.getDescriptionElement(), -1); 17918 } 17919 for (int i = 0; i < element.getUseContext().size(); i++) { 17920 composeUsageContext(t, "Questionnaire", "useContext", element.getUseContext().get(i), i); 17921 } 17922 for (int i = 0; i < element.getJurisdiction().size(); i++) { 17923 composeCodeableConcept(t, "Questionnaire", "jurisdiction", element.getJurisdiction().get(i), i); 17924 } 17925 if (element.hasPurposeElement()) { 17926 composeMarkdown(t, "Questionnaire", "purpose", element.getPurposeElement(), -1); 17927 } 17928 if (element.hasCopyrightElement()) { 17929 composeMarkdown(t, "Questionnaire", "copyright", element.getCopyrightElement(), -1); 17930 } 17931 if (element.hasApprovalDateElement()) { 17932 composeDate(t, "Questionnaire", "approvalDate", element.getApprovalDateElement(), -1); 17933 } 17934 if (element.hasLastReviewDateElement()) { 17935 composeDate(t, "Questionnaire", "lastReviewDate", element.getLastReviewDateElement(), -1); 17936 } 17937 if (element.hasEffectivePeriod()) { 17938 composePeriod(t, "Questionnaire", "effectivePeriod", element.getEffectivePeriod(), -1); 17939 } 17940 for (int i = 0; i < element.getCode().size(); i++) { 17941 composeCoding(t, "Questionnaire", "code", element.getCode().get(i), i); 17942 } 17943 for (int i = 0; i < element.getItem().size(); i++) { 17944 composeQuestionnaireItemComponent(t, "Questionnaire", "item", element.getItem().get(i), i); 17945 } 17946 } 17947 17948 protected void composeQuestionnaireItemComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemComponent element, int index) { 17949 if (element == null) 17950 return; 17951 Complex t; 17952 if (Utilities.noString(parentType)) 17953 t = parent; 17954 else { 17955 t = parent.predicate("fhir:"+parentType+'.'+name); 17956 } 17957 composeBackboneElement(t, "item", name, element, index); 17958 if (element.hasLinkIdElement()) { 17959 composeString(t, "QuestionnaireItemComponent", "linkId", element.getLinkIdElement(), -1); 17960 } 17961 if (element.hasDefinitionElement()) { 17962 composeUri(t, "QuestionnaireItemComponent", "definition", element.getDefinitionElement(), -1); 17963 } 17964 for (int i = 0; i < element.getCode().size(); i++) { 17965 composeCoding(t, "QuestionnaireItemComponent", "code", element.getCode().get(i), i); 17966 } 17967 if (element.hasPrefixElement()) { 17968 composeString(t, "QuestionnaireItemComponent", "prefix", element.getPrefixElement(), -1); 17969 } 17970 if (element.hasTextElement()) { 17971 composeString(t, "QuestionnaireItemComponent", "text", element.getTextElement(), -1); 17972 } 17973 if (element.hasTypeElement()) { 17974 composeEnum(t, "QuestionnaireItemComponent", "type", element.getTypeElement(), -1); 17975 } 17976 for (int i = 0; i < element.getEnableWhen().size(); i++) { 17977 composeQuestionnaireItemEnableWhenComponent(t, "QuestionnaireItemComponent", "enableWhen", element.getEnableWhen().get(i), i); 17978 } 17979 if (element.hasEnableBehaviorElement()) { 17980 composeEnum(t, "QuestionnaireItemComponent", "enableBehavior", element.getEnableBehaviorElement(), -1); 17981 } 17982 if (element.hasRequiredElement()) { 17983 composeBoolean(t, "QuestionnaireItemComponent", "required", element.getRequiredElement(), -1); 17984 } 17985 if (element.hasRepeatsElement()) { 17986 composeBoolean(t, "QuestionnaireItemComponent", "repeats", element.getRepeatsElement(), -1); 17987 } 17988 if (element.hasReadOnlyElement()) { 17989 composeBoolean(t, "QuestionnaireItemComponent", "readOnly", element.getReadOnlyElement(), -1); 17990 } 17991 if (element.hasMaxLengthElement()) { 17992 composeInteger(t, "QuestionnaireItemComponent", "maxLength", element.getMaxLengthElement(), -1); 17993 } 17994 if (element.hasAnswerValueSetElement()) { 17995 composeCanonical(t, "QuestionnaireItemComponent", "answerValueSet", element.getAnswerValueSetElement(), -1); 17996 } 17997 for (int i = 0; i < element.getAnswerOption().size(); i++) { 17998 composeQuestionnaireItemAnswerOptionComponent(t, "QuestionnaireItemComponent", "answerOption", element.getAnswerOption().get(i), i); 17999 } 18000 for (int i = 0; i < element.getInitial().size(); i++) { 18001 composeQuestionnaireItemInitialComponent(t, "QuestionnaireItemComponent", "initial", element.getInitial().get(i), i); 18002 } 18003 for (int i = 0; i < element.getItem().size(); i++) { 18004 composeQuestionnaireItemComponent(t, "QuestionnaireItemComponent", "item", element.getItem().get(i), i); 18005 } 18006 } 18007 18008 protected void composeQuestionnaireItemEnableWhenComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemEnableWhenComponent element, int index) { 18009 if (element == null) 18010 return; 18011 Complex t; 18012 if (Utilities.noString(parentType)) 18013 t = parent; 18014 else { 18015 t = parent.predicate("fhir:"+parentType+'.'+name); 18016 } 18017 composeBackboneElement(t, "enableWhen", name, element, index); 18018 if (element.hasQuestionElement()) { 18019 composeString(t, "QuestionnaireItemEnableWhenComponent", "question", element.getQuestionElement(), -1); 18020 } 18021 if (element.hasOperatorElement()) { 18022 composeEnum(t, "QuestionnaireItemEnableWhenComponent", "operator", element.getOperatorElement(), -1); 18023 } 18024 if (element.hasAnswer()) { 18025 composeType(t, "QuestionnaireItemEnableWhenComponent", "answer", element.getAnswer(), -1); 18026 } 18027 } 18028 18029 protected void composeQuestionnaireItemAnswerOptionComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemAnswerOptionComponent element, int index) { 18030 if (element == null) 18031 return; 18032 Complex t; 18033 if (Utilities.noString(parentType)) 18034 t = parent; 18035 else { 18036 t = parent.predicate("fhir:"+parentType+'.'+name); 18037 } 18038 composeBackboneElement(t, "answerOption", name, element, index); 18039 if (element.hasValue()) { 18040 composeType(t, "QuestionnaireItemAnswerOptionComponent", "value", element.getValue(), -1); 18041 } 18042 if (element.hasInitialSelectedElement()) { 18043 composeBoolean(t, "QuestionnaireItemAnswerOptionComponent", "initialSelected", element.getInitialSelectedElement(), -1); 18044 } 18045 } 18046 18047 protected void composeQuestionnaireItemInitialComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemInitialComponent element, int index) { 18048 if (element == null) 18049 return; 18050 Complex t; 18051 if (Utilities.noString(parentType)) 18052 t = parent; 18053 else { 18054 t = parent.predicate("fhir:"+parentType+'.'+name); 18055 } 18056 composeBackboneElement(t, "initial", name, element, index); 18057 if (element.hasValue()) { 18058 composeType(t, "QuestionnaireItemInitialComponent", "value", element.getValue(), -1); 18059 } 18060 } 18061 18062 protected void composeQuestionnaireResponse(Complex parent, String parentType, String name, QuestionnaireResponse element, int index) { 18063 if (element == null) 18064 return; 18065 Complex t; 18066 if (Utilities.noString(parentType)) 18067 t = parent; 18068 else { 18069 t = parent.predicate("fhir:"+parentType+'.'+name); 18070 } 18071 composeDomainResource(t, "QuestionnaireResponse", name, element, index); 18072 if (element.hasIdentifier()) { 18073 composeIdentifier(t, "QuestionnaireResponse", "identifier", element.getIdentifier(), -1); 18074 } 18075 for (int i = 0; i < element.getBasedOn().size(); i++) { 18076 composeReference(t, "QuestionnaireResponse", "basedOn", element.getBasedOn().get(i), i); 18077 } 18078 for (int i = 0; i < element.getPartOf().size(); i++) { 18079 composeReference(t, "QuestionnaireResponse", "partOf", element.getPartOf().get(i), i); 18080 } 18081 if (element.hasQuestionnaireElement()) { 18082 composeCanonical(t, "QuestionnaireResponse", "questionnaire", element.getQuestionnaireElement(), -1); 18083 } 18084 if (element.hasStatusElement()) { 18085 composeEnum(t, "QuestionnaireResponse", "status", element.getStatusElement(), -1); 18086 } 18087 if (element.hasSubject()) { 18088 composeReference(t, "QuestionnaireResponse", "subject", element.getSubject(), -1); 18089 } 18090 if (element.hasEncounter()) { 18091 composeReference(t, "QuestionnaireResponse", "encounter", element.getEncounter(), -1); 18092 } 18093 if (element.hasAuthoredElement()) { 18094 composeDateTime(t, "QuestionnaireResponse", "authored", element.getAuthoredElement(), -1); 18095 } 18096 if (element.hasAuthor()) { 18097 composeReference(t, "QuestionnaireResponse", "author", element.getAuthor(), -1); 18098 } 18099 if (element.hasSource()) { 18100 composeReference(t, "QuestionnaireResponse", "source", element.getSource(), -1); 18101 } 18102 for (int i = 0; i < element.getItem().size(); i++) { 18103 composeQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i); 18104 } 18105 } 18106 18107 protected void composeQuestionnaireResponseItemComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemComponent element, int index) { 18108 if (element == null) 18109 return; 18110 Complex t; 18111 if (Utilities.noString(parentType)) 18112 t = parent; 18113 else { 18114 t = parent.predicate("fhir:"+parentType+'.'+name); 18115 } 18116 composeBackboneElement(t, "item", name, element, index); 18117 if (element.hasLinkIdElement()) { 18118 composeString(t, "QuestionnaireResponseItemComponent", "linkId", element.getLinkIdElement(), -1); 18119 } 18120 if (element.hasDefinitionElement()) { 18121 composeUri(t, "QuestionnaireResponseItemComponent", "definition", element.getDefinitionElement(), -1); 18122 } 18123 if (element.hasTextElement()) { 18124 composeString(t, "QuestionnaireResponseItemComponent", "text", element.getTextElement(), -1); 18125 } 18126 for (int i = 0; i < element.getAnswer().size(); i++) { 18127 composeQuestionnaireResponseItemAnswerComponent(t, "QuestionnaireResponseItemComponent", "answer", element.getAnswer().get(i), i); 18128 } 18129 for (int i = 0; i < element.getItem().size(); i++) { 18130 composeQuestionnaireResponseItemComponent(t, "QuestionnaireResponseItemComponent", "item", element.getItem().get(i), i); 18131 } 18132 } 18133 18134 protected void composeQuestionnaireResponseItemAnswerComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent element, int index) { 18135 if (element == null) 18136 return; 18137 Complex t; 18138 if (Utilities.noString(parentType)) 18139 t = parent; 18140 else { 18141 t = parent.predicate("fhir:"+parentType+'.'+name); 18142 } 18143 composeBackboneElement(t, "answer", name, element, index); 18144 if (element.hasValue()) { 18145 composeType(t, "QuestionnaireResponseItemAnswerComponent", "value", element.getValue(), -1); 18146 } 18147 for (int i = 0; i < element.getItem().size(); i++) { 18148 composeQuestionnaireResponseItemComponent(t, "QuestionnaireResponseItemAnswerComponent", "item", element.getItem().get(i), i); 18149 } 18150 } 18151 18152 protected void composeRegulatedAuthorization(Complex parent, String parentType, String name, RegulatedAuthorization element, int index) { 18153 if (element == null) 18154 return; 18155 Complex t; 18156 if (Utilities.noString(parentType)) 18157 t = parent; 18158 else { 18159 t = parent.predicate("fhir:"+parentType+'.'+name); 18160 } 18161 composeDomainResource(t, "RegulatedAuthorization", name, element, index); 18162 for (int i = 0; i < element.getIdentifier().size(); i++) { 18163 composeIdentifier(t, "RegulatedAuthorization", "identifier", element.getIdentifier().get(i), i); 18164 } 18165 if (element.hasSubject()) { 18166 composeReference(t, "RegulatedAuthorization", "subject", element.getSubject(), -1); 18167 } 18168 if (element.hasType()) { 18169 composeCodeableConcept(t, "RegulatedAuthorization", "type", element.getType(), -1); 18170 } 18171 if (element.hasDescriptionElement()) { 18172 composeMarkdown(t, "RegulatedAuthorization", "description", element.getDescriptionElement(), -1); 18173 } 18174 for (int i = 0; i < element.getRegion().size(); i++) { 18175 composeCodeableConcept(t, "RegulatedAuthorization", "region", element.getRegion().get(i), i); 18176 } 18177 if (element.hasStatus()) { 18178 composeCodeableConcept(t, "RegulatedAuthorization", "status", element.getStatus(), -1); 18179 } 18180 if (element.hasStatusDateElement()) { 18181 composeDateTime(t, "RegulatedAuthorization", "statusDate", element.getStatusDateElement(), -1); 18182 } 18183 if (element.hasValidityPeriod()) { 18184 composePeriod(t, "RegulatedAuthorization", "validityPeriod", element.getValidityPeriod(), -1); 18185 } 18186 for (int i = 0; i < element.getBasis().size(); i++) { 18187 composeCodeableConcept(t, "RegulatedAuthorization", "basis", element.getBasis().get(i), i); 18188 } 18189 for (int i = 0; i < element.getRelatedDate().size(); i++) { 18190 composeRegulatedAuthorizationRelatedDateComponent(t, "RegulatedAuthorization", "relatedDate", element.getRelatedDate().get(i), i); 18191 } 18192 for (int i = 0; i < element.getJurisdictionalAuthorization().size(); i++) { 18193 composeReference(t, "RegulatedAuthorization", "jurisdictionalAuthorization", element.getJurisdictionalAuthorization().get(i), i); 18194 } 18195 if (element.hasHolder()) { 18196 composeReference(t, "RegulatedAuthorization", "holder", element.getHolder(), -1); 18197 } 18198 if (element.hasRegulator()) { 18199 composeReference(t, "RegulatedAuthorization", "regulator", element.getRegulator(), -1); 18200 } 18201 if (element.hasCase()) { 18202 composeRegulatedAuthorizationCaseComponent(t, "RegulatedAuthorization", "case", element.getCase(), -1); 18203 } 18204 } 18205 18206 protected void composeRegulatedAuthorizationRelatedDateComponent(Complex parent, String parentType, String name, RegulatedAuthorization.RegulatedAuthorizationRelatedDateComponent element, int index) { 18207 if (element == null) 18208 return; 18209 Complex t; 18210 if (Utilities.noString(parentType)) 18211 t = parent; 18212 else { 18213 t = parent.predicate("fhir:"+parentType+'.'+name); 18214 } 18215 composeBackboneElement(t, "relatedDate", name, element, index); 18216 if (element.hasDate()) { 18217 composeType(t, "RegulatedAuthorizationRelatedDateComponent", "date", element.getDate(), -1); 18218 } 18219 if (element.hasType()) { 18220 composeCodeableConcept(t, "RegulatedAuthorizationRelatedDateComponent", "type", element.getType(), -1); 18221 } 18222 } 18223 18224 protected void composeRegulatedAuthorizationCaseComponent(Complex parent, String parentType, String name, RegulatedAuthorization.RegulatedAuthorizationCaseComponent element, int index) { 18225 if (element == null) 18226 return; 18227 Complex t; 18228 if (Utilities.noString(parentType)) 18229 t = parent; 18230 else { 18231 t = parent.predicate("fhir:"+parentType+'.'+name); 18232 } 18233 composeBackboneElement(t, "case", name, element, index); 18234 if (element.hasIdentifier()) { 18235 composeIdentifier(t, "RegulatedAuthorizationCaseComponent", "identifier", element.getIdentifier(), -1); 18236 } 18237 if (element.hasType()) { 18238 composeCodeableConcept(t, "RegulatedAuthorizationCaseComponent", "type", element.getType(), -1); 18239 } 18240 if (element.hasStatus()) { 18241 composeCodeableConcept(t, "RegulatedAuthorizationCaseComponent", "status", element.getStatus(), -1); 18242 } 18243 if (element.hasDate()) { 18244 composeType(t, "RegulatedAuthorizationCaseComponent", "date", element.getDate(), -1); 18245 } 18246 for (int i = 0; i < element.getApplication().size(); i++) { 18247 composeRegulatedAuthorizationCaseComponent(t, "RegulatedAuthorizationCaseComponent", "application", element.getApplication().get(i), i); 18248 } 18249 } 18250 18251 protected void composeRelatedPerson(Complex parent, String parentType, String name, RelatedPerson element, int index) { 18252 if (element == null) 18253 return; 18254 Complex t; 18255 if (Utilities.noString(parentType)) 18256 t = parent; 18257 else { 18258 t = parent.predicate("fhir:"+parentType+'.'+name); 18259 } 18260 composeDomainResource(t, "RelatedPerson", name, element, index); 18261 for (int i = 0; i < element.getIdentifier().size(); i++) { 18262 composeIdentifier(t, "RelatedPerson", "identifier", element.getIdentifier().get(i), i); 18263 } 18264 if (element.hasActiveElement()) { 18265 composeBoolean(t, "RelatedPerson", "active", element.getActiveElement(), -1); 18266 } 18267 if (element.hasPatient()) { 18268 composeReference(t, "RelatedPerson", "patient", element.getPatient(), -1); 18269 } 18270 for (int i = 0; i < element.getRelationship().size(); i++) { 18271 composeCodeableConcept(t, "RelatedPerson", "relationship", element.getRelationship().get(i), i); 18272 } 18273 for (int i = 0; i < element.getName().size(); i++) { 18274 composeHumanName(t, "RelatedPerson", "name", element.getName().get(i), i); 18275 } 18276 for (int i = 0; i < element.getTelecom().size(); i++) { 18277 composeContactPoint(t, "RelatedPerson", "telecom", element.getTelecom().get(i), i); 18278 } 18279 if (element.hasGenderElement()) { 18280 composeEnum(t, "RelatedPerson", "gender", element.getGenderElement(), -1); 18281 } 18282 if (element.hasBirthDateElement()) { 18283 composeDate(t, "RelatedPerson", "birthDate", element.getBirthDateElement(), -1); 18284 } 18285 for (int i = 0; i < element.getAddress().size(); i++) { 18286 composeAddress(t, "RelatedPerson", "address", element.getAddress().get(i), i); 18287 } 18288 for (int i = 0; i < element.getPhoto().size(); i++) { 18289 composeAttachment(t, "RelatedPerson", "photo", element.getPhoto().get(i), i); 18290 } 18291 if (element.hasPeriod()) { 18292 composePeriod(t, "RelatedPerson", "period", element.getPeriod(), -1); 18293 } 18294 for (int i = 0; i < element.getCommunication().size(); i++) { 18295 composeRelatedPersonCommunicationComponent(t, "RelatedPerson", "communication", element.getCommunication().get(i), i); 18296 } 18297 } 18298 18299 protected void composeRelatedPersonCommunicationComponent(Complex parent, String parentType, String name, RelatedPerson.RelatedPersonCommunicationComponent element, int index) { 18300 if (element == null) 18301 return; 18302 Complex t; 18303 if (Utilities.noString(parentType)) 18304 t = parent; 18305 else { 18306 t = parent.predicate("fhir:"+parentType+'.'+name); 18307 } 18308 composeBackboneElement(t, "communication", name, element, index); 18309 if (element.hasLanguage()) { 18310 composeCodeableConcept(t, "RelatedPersonCommunicationComponent", "language", element.getLanguage(), -1); 18311 } 18312 if (element.hasPreferredElement()) { 18313 composeBoolean(t, "RelatedPersonCommunicationComponent", "preferred", element.getPreferredElement(), -1); 18314 } 18315 } 18316 18317 protected void composeRequestGroup(Complex parent, String parentType, String name, RequestGroup element, int index) { 18318 if (element == null) 18319 return; 18320 Complex t; 18321 if (Utilities.noString(parentType)) 18322 t = parent; 18323 else { 18324 t = parent.predicate("fhir:"+parentType+'.'+name); 18325 } 18326 composeDomainResource(t, "RequestGroup", name, element, index); 18327 for (int i = 0; i < element.getIdentifier().size(); i++) { 18328 composeIdentifier(t, "RequestGroup", "identifier", element.getIdentifier().get(i), i); 18329 } 18330 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) { 18331 composeCanonical(t, "RequestGroup", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 18332 } 18333 for (int i = 0; i < element.getInstantiatesUri().size(); i++) { 18334 composeUri(t, "RequestGroup", "instantiatesUri", element.getInstantiatesUri().get(i), i); 18335 } 18336 for (int i = 0; i < element.getBasedOn().size(); i++) { 18337 composeReference(t, "RequestGroup", "basedOn", element.getBasedOn().get(i), i); 18338 } 18339 for (int i = 0; i < element.getReplaces().size(); i++) { 18340 composeReference(t, "RequestGroup", "replaces", element.getReplaces().get(i), i); 18341 } 18342 if (element.hasGroupIdentifier()) { 18343 composeIdentifier(t, "RequestGroup", "groupIdentifier", element.getGroupIdentifier(), -1); 18344 } 18345 if (element.hasStatusElement()) { 18346 composeEnum(t, "RequestGroup", "status", element.getStatusElement(), -1); 18347 } 18348 if (element.hasIntentElement()) { 18349 composeEnum(t, "RequestGroup", "intent", element.getIntentElement(), -1); 18350 } 18351 if (element.hasPriorityElement()) { 18352 composeEnum(t, "RequestGroup", "priority", element.getPriorityElement(), -1); 18353 } 18354 if (element.hasCode()) { 18355 composeCodeableConcept(t, "RequestGroup", "code", element.getCode(), -1); 18356 } 18357 if (element.hasSubject()) { 18358 composeReference(t, "RequestGroup", "subject", element.getSubject(), -1); 18359 } 18360 if (element.hasEncounter()) { 18361 composeReference(t, "RequestGroup", "encounter", element.getEncounter(), -1); 18362 } 18363 if (element.hasAuthoredOnElement()) { 18364 composeDateTime(t, "RequestGroup", "authoredOn", element.getAuthoredOnElement(), -1); 18365 } 18366 if (element.hasAuthor()) { 18367 composeReference(t, "RequestGroup", "author", element.getAuthor(), -1); 18368 } 18369 for (int i = 0; i < element.getReason().size(); i++) { 18370 composeCodeableReference(t, "RequestGroup", "reason", element.getReason().get(i), i); 18371 } 18372 for (int i = 0; i < element.getNote().size(); i++) { 18373 composeAnnotation(t, "RequestGroup", "note", element.getNote().get(i), i); 18374 } 18375 for (int i = 0; i < element.getAction().size(); i++) { 18376 composeRequestGroupActionComponent(t, "RequestGroup", "action", element.getAction().get(i), i); 18377 } 18378 } 18379 18380 protected void composeRequestGroupActionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionComponent element, int index) { 18381 if (element == null) 18382 return; 18383 Complex t; 18384 if (Utilities.noString(parentType)) 18385 t = parent; 18386 else { 18387 t = parent.predicate("fhir:"+parentType+'.'+name); 18388 } 18389 composeBackboneElement(t, "action", name, element, index); 18390 if (element.hasPrefixElement()) { 18391 composeString(t, "RequestGroupActionComponent", "prefix", element.getPrefixElement(), -1); 18392 } 18393 if (element.hasTitleElement()) { 18394 composeString(t, "RequestGroupActionComponent", "title", element.getTitleElement(), -1); 18395 } 18396 if (element.hasDescriptionElement()) { 18397 composeString(t, "RequestGroupActionComponent", "description", element.getDescriptionElement(), -1); 18398 } 18399 if (element.hasTextEquivalentElement()) { 18400 composeString(t, "RequestGroupActionComponent", "textEquivalent", element.getTextEquivalentElement(), -1); 18401 } 18402 if (element.hasPriorityElement()) { 18403 composeEnum(t, "RequestGroupActionComponent", "priority", element.getPriorityElement(), -1); 18404 } 18405 for (int i = 0; i < element.getCode().size(); i++) { 18406 composeCodeableConcept(t, "RequestGroupActionComponent", "code", element.getCode().get(i), i); 18407 } 18408 for (int i = 0; i < element.getDocumentation().size(); i++) { 18409 composeRelatedArtifact(t, "RequestGroupActionComponent", "documentation", element.getDocumentation().get(i), i); 18410 } 18411 for (int i = 0; i < element.getCondition().size(); i++) { 18412 composeRequestGroupActionConditionComponent(t, "RequestGroupActionComponent", "condition", element.getCondition().get(i), i); 18413 } 18414 for (int i = 0; i < element.getRelatedAction().size(); i++) { 18415 composeRequestGroupActionRelatedActionComponent(t, "RequestGroupActionComponent", "relatedAction", element.getRelatedAction().get(i), i); 18416 } 18417 if (element.hasTiming()) { 18418 composeType(t, "RequestGroupActionComponent", "timing", element.getTiming(), -1); 18419 } 18420 for (int i = 0; i < element.getParticipant().size(); i++) { 18421 composeReference(t, "RequestGroupActionComponent", "participant", element.getParticipant().get(i), i); 18422 } 18423 if (element.hasType()) { 18424 composeCodeableConcept(t, "RequestGroupActionComponent", "type", element.getType(), -1); 18425 } 18426 if (element.hasGroupingBehaviorElement()) { 18427 composeEnum(t, "RequestGroupActionComponent", "groupingBehavior", element.getGroupingBehaviorElement(), -1); 18428 } 18429 if (element.hasSelectionBehaviorElement()) { 18430 composeEnum(t, "RequestGroupActionComponent", "selectionBehavior", element.getSelectionBehaviorElement(), -1); 18431 } 18432 if (element.hasRequiredBehaviorElement()) { 18433 composeEnum(t, "RequestGroupActionComponent", "requiredBehavior", element.getRequiredBehaviorElement(), -1); 18434 } 18435 if (element.hasPrecheckBehaviorElement()) { 18436 composeEnum(t, "RequestGroupActionComponent", "precheckBehavior", element.getPrecheckBehaviorElement(), -1); 18437 } 18438 if (element.hasCardinalityBehaviorElement()) { 18439 composeEnum(t, "RequestGroupActionComponent", "cardinalityBehavior", element.getCardinalityBehaviorElement(), -1); 18440 } 18441 if (element.hasResource()) { 18442 composeReference(t, "RequestGroupActionComponent", "resource", element.getResource(), -1); 18443 } 18444 for (int i = 0; i < element.getAction().size(); i++) { 18445 composeRequestGroupActionComponent(t, "RequestGroupActionComponent", "action", element.getAction().get(i), i); 18446 } 18447 } 18448 18449 protected void composeRequestGroupActionConditionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionConditionComponent element, int index) { 18450 if (element == null) 18451 return; 18452 Complex t; 18453 if (Utilities.noString(parentType)) 18454 t = parent; 18455 else { 18456 t = parent.predicate("fhir:"+parentType+'.'+name); 18457 } 18458 composeBackboneElement(t, "condition", name, element, index); 18459 if (element.hasKindElement()) { 18460 composeEnum(t, "RequestGroupActionConditionComponent", "kind", element.getKindElement(), -1); 18461 } 18462 if (element.hasExpression()) { 18463 composeExpression(t, "RequestGroupActionConditionComponent", "expression", element.getExpression(), -1); 18464 } 18465 } 18466 18467 protected void composeRequestGroupActionRelatedActionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionRelatedActionComponent element, int index) { 18468 if (element == null) 18469 return; 18470 Complex t; 18471 if (Utilities.noString(parentType)) 18472 t = parent; 18473 else { 18474 t = parent.predicate("fhir:"+parentType+'.'+name); 18475 } 18476 composeBackboneElement(t, "relatedAction", name, element, index); 18477 if (element.hasActionIdElement()) { 18478 composeId(t, "RequestGroupActionRelatedActionComponent", "actionId", element.getActionIdElement(), -1); 18479 } 18480 if (element.hasRelationshipElement()) { 18481 composeEnum(t, "RequestGroupActionRelatedActionComponent", "relationship", element.getRelationshipElement(), -1); 18482 } 18483 if (element.hasOffset()) { 18484 composeType(t, "RequestGroupActionRelatedActionComponent", "offset", element.getOffset(), -1); 18485 } 18486 } 18487 18488 protected void composeResearchStudy(Complex parent, String parentType, String name, ResearchStudy element, int index) { 18489 if (element == null) 18490 return; 18491 Complex t; 18492 if (Utilities.noString(parentType)) 18493 t = parent; 18494 else { 18495 t = parent.predicate("fhir:"+parentType+'.'+name); 18496 } 18497 composeDomainResource(t, "ResearchStudy", name, element, index); 18498 for (int i = 0; i < element.getIdentifier().size(); i++) { 18499 composeIdentifier(t, "ResearchStudy", "identifier", element.getIdentifier().get(i), i); 18500 } 18501 if (element.hasTitleElement()) { 18502 composeString(t, "ResearchStudy", "title", element.getTitleElement(), -1); 18503 } 18504 for (int i = 0; i < element.getProtocol().size(); i++) { 18505 composeReference(t, "ResearchStudy", "protocol", element.getProtocol().get(i), i); 18506 } 18507 for (int i = 0; i < element.getPartOf().size(); i++) { 18508 composeReference(t, "ResearchStudy", "partOf", element.getPartOf().get(i), i); 18509 } 18510 if (element.hasStatusElement()) { 18511 composeEnum(t, "ResearchStudy", "status", element.getStatusElement(), -1); 18512 } 18513 if (element.hasPrimaryPurposeType()) { 18514 composeCodeableConcept(t, "ResearchStudy", "primaryPurposeType", element.getPrimaryPurposeType(), -1); 18515 } 18516 if (element.hasPhase()) { 18517 composeCodeableConcept(t, "ResearchStudy", "phase", element.getPhase(), -1); 18518 } 18519 for (int i = 0; i < element.getCategory().size(); i++) { 18520 composeCodeableConcept(t, "ResearchStudy", "category", element.getCategory().get(i), i); 18521 } 18522 for (int i = 0; i < element.getFocus().size(); i++) { 18523 composeCodeableConcept(t, "ResearchStudy", "focus", element.getFocus().get(i), i); 18524 } 18525 for (int i = 0; i < element.getCondition().size(); i++) { 18526 composeCodeableConcept(t, "ResearchStudy", "condition", element.getCondition().get(i), i); 18527 } 18528 for (int i = 0; i < element.getContact().size(); i++) { 18529 composeContactDetail(t, "ResearchStudy", "contact", element.getContact().get(i), i); 18530 } 18531 for (int i = 0; i < element.getRelatedArtifact().size(); i++) { 18532 composeRelatedArtifact(t, "ResearchStudy", "relatedArtifact", element.getRelatedArtifact().get(i), i); 18533 } 18534 for (int i = 0; i < element.getKeyword().size(); i++) { 18535 composeCodeableConcept(t, "ResearchStudy", "keyword", element.getKeyword().get(i), i); 18536 } 18537 for (int i = 0; i < element.getLocation().size(); i++) { 18538 composeCodeableConcept(t, "ResearchStudy", "location", element.getLocation().get(i), i); 18539 } 18540 if (element.hasDescriptionElement()) { 18541 composeMarkdown(t, "ResearchStudy", "description", element.getDescriptionElement(), -1); 18542 } 18543 for (int i = 0; i < element.getEnrollment().size(); i++) { 18544 composeReference(t, "ResearchStudy", "enrollment", element.getEnrollment().get(i), i); 18545 } 18546 if (element.hasPeriod()) { 18547 composePeriod(t, "ResearchStudy", "period", element.getPeriod(), -1); 18548 } 18549 if (element.hasSponsor()) { 18550 composeReference(t, "ResearchStudy", "sponsor", element.getSponsor(), -1); 18551 } 18552 if (element.hasPrincipalInvestigator()) { 18553 composeReference(t, "ResearchStudy", "principalInvestigator", element.getPrincipalInvestigator(), -1); 18554 } 18555 for (int i = 0; i < element.getSite().size(); i++) { 18556 composeReference(t, "ResearchStudy", "site", element.getSite().get(i), i); 18557 } 18558 if (element.hasReasonStopped()) { 18559 composeCodeableConcept(t, "ResearchStudy", "reasonStopped", element.getReasonStopped(), -1); 18560 } 18561 for (int i = 0; i < element.getNote().size(); i++) { 18562 composeAnnotation(t, "ResearchStudy", "note", element.getNote().get(i), i); 18563 } 18564 for (int i = 0; i < element.getArm().size(); i++) { 18565 composeResearchStudyArmComponent(t, "ResearchStudy", "arm", element.getArm().get(i), i); 18566 } 18567 for (int i = 0; i < element.getObjective().size(); i++) { 18568 composeResearchStudyObjectiveComponent(t, "ResearchStudy", "objective", element.getObjective().get(i), i); 18569 } 18570 } 18571 18572 protected void composeResearchStudyArmComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyArmComponent element, int index) { 18573 if (element == null) 18574 return; 18575 Complex t; 18576 if (Utilities.noString(parentType)) 18577 t = parent; 18578 else { 18579 t = parent.predicate("fhir:"+parentType+'.'+name); 18580 } 18581 composeBackboneElement(t, "arm", name, element, index); 18582 if (element.hasNameElement()) { 18583 composeString(t, "ResearchStudyArmComponent", "name", element.getNameElement(), -1); 18584 } 18585 if (element.hasType()) { 18586 composeCodeableConcept(t, "ResearchStudyArmComponent", "type", element.getType(), -1); 18587 } 18588 if (element.hasDescriptionElement()) { 18589 composeString(t, "ResearchStudyArmComponent", "description", element.getDescriptionElement(), -1); 18590 } 18591 } 18592 18593 protected void composeResearchStudyObjectiveComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyObjectiveComponent element, int index) { 18594 if (element == null) 18595 return; 18596 Complex t; 18597 if (Utilities.noString(parentType)) 18598 t = parent; 18599 else { 18600 t = parent.predicate("fhir:"+parentType+'.'+name); 18601 } 18602 composeBackboneElement(t, "objective", name, element, index); 18603 if (element.hasNameElement()) { 18604 composeString(t, "ResearchStudyObjectiveComponent", "name", element.getNameElement(), -1); 18605 } 18606 if (element.hasType()) { 18607 composeCodeableConcept(t, "ResearchStudyObjectiveComponent", "type", element.getType(), -1); 18608 } 18609 } 18610 18611 protected void composeResearchSubject(Complex parent, String parentType, String name, ResearchSubject element, int index) { 18612 if (element == null) 18613 return; 18614 Complex t; 18615 if (Utilities.noString(parentType)) 18616 t = parent; 18617 else { 18618 t = parent.predicate("fhir:"+parentType+'.'+name); 18619 } 18620 composeDomainResource(t, "ResearchSubject", name, element, index); 18621 for (int i = 0; i < element.getIdentifier().size(); i++) { 18622 composeIdentifier(t, "ResearchSubject", "identifier", element.getIdentifier().get(i), i); 18623 } 18624 if (element.hasStatusElement()) { 18625 composeEnum(t, "ResearchSubject", "status", element.getStatusElement(), -1); 18626 } 18627 for (int i = 0; i < element.getProgress().size(); i++) { 18628 composeResearchSubjectProgressComponent(t, "ResearchSubject", "progress", element.getProgress().get(i), i); 18629 } 18630 if (element.hasPeriod()) { 18631 composePeriod(t, "ResearchSubject", "period", element.getPeriod(), -1); 18632 } 18633 if (element.hasStudy()) { 18634 composeReference(t, "ResearchSubject", "study", element.getStudy(), -1); 18635 } 18636 if (element.hasIndividual()) { 18637 composeReference(t, "ResearchSubject", "individual", element.getIndividual(), -1); 18638 } 18639 if (element.hasAssignedArmElement()) { 18640 composeString(t, "ResearchSubject", "assignedArm", element.getAssignedArmElement(), -1); 18641 } 18642 if (element.hasActualArmElement()) { 18643 composeString(t, "ResearchSubject", "actualArm", element.getActualArmElement(), -1); 18644 } 18645 if (element.hasConsent()) { 18646 composeReference(t, "ResearchSubject", "consent", element.getConsent(), -1); 18647 } 18648 } 18649 18650 protected void composeResearchSubjectProgressComponent(Complex parent, String parentType, String name, ResearchSubject.ResearchSubjectProgressComponent element, int index) { 18651 if (element == null) 18652 return; 18653 Complex t; 18654 if (Utilities.noString(parentType)) 18655 t = parent; 18656 else { 18657 t = parent.predicate("fhir:"+parentType+'.'+name); 18658 } 18659 composeBackboneElement(t, "progress", name, element, index); 18660 if (element.hasType()) { 18661 composeCodeableConcept(t, "ResearchSubjectProgressComponent", "type", element.getType(), -1); 18662 } 18663 if (element.hasState()) { 18664 composeCodeableConcept(t, "ResearchSubjectProgressComponent", "state", element.getState(), -1); 18665 } 18666 if (element.hasMilestone()) { 18667 composeCodeableConcept(t, "ResearchSubjectProgressComponent", "milestone", element.getMilestone(), -1); 18668 } 18669 if (element.hasReason()) { 18670 composeCodeableConcept(t, "ResearchSubjectProgressComponent", "reason", element.getReason(), -1); 18671 } 18672 if (element.hasStartDateElement()) { 18673 composeDateTime(t, "ResearchSubjectProgressComponent", "startDate", element.getStartDateElement(), -1); 18674 } 18675 } 18676 18677 protected void composeRiskAssessment(Complex parent, String parentType, String name, RiskAssessment element, int index) { 18678 if (element == null) 18679 return; 18680 Complex t; 18681 if (Utilities.noString(parentType)) 18682 t = parent; 18683 else { 18684 t = parent.predicate("fhir:"+parentType+'.'+name); 18685 } 18686 composeDomainResource(t, "RiskAssessment", name, element, index); 18687 for (int i = 0; i < element.getIdentifier().size(); i++) { 18688 composeIdentifier(t, "RiskAssessment", "identifier", element.getIdentifier().get(i), i); 18689 } 18690 if (element.hasBasedOn()) { 18691 composeReference(t, "RiskAssessment", "basedOn", element.getBasedOn(), -1); 18692 } 18693 if (element.hasParent()) { 18694 composeReference(t, "RiskAssessment", "parent", element.getParent(), -1); 18695 } 18696 if (element.hasStatusElement()) { 18697 composeEnum(t, "RiskAssessment", "status", element.getStatusElement(), -1); 18698 } 18699 if (element.hasMethod()) { 18700 composeCodeableConcept(t, "RiskAssessment", "method", element.getMethod(), -1); 18701 } 18702 if (element.hasCode()) { 18703 composeCodeableConcept(t, "RiskAssessment", "code", element.getCode(), -1); 18704 } 18705 if (element.hasSubject()) { 18706 composeReference(t, "RiskAssessment", "subject", element.getSubject(), -1); 18707 } 18708 if (element.hasEncounter()) { 18709 composeReference(t, "RiskAssessment", "encounter", element.getEncounter(), -1); 18710 } 18711 if (element.hasOccurrence()) { 18712 composeType(t, "RiskAssessment", "occurrence", element.getOccurrence(), -1); 18713 } 18714 if (element.hasCondition()) { 18715 composeReference(t, "RiskAssessment", "condition", element.getCondition(), -1); 18716 } 18717 if (element.hasPerformer()) { 18718 composeReference(t, "RiskAssessment", "performer", element.getPerformer(), -1); 18719 } 18720 for (int i = 0; i < element.getReason().size(); i++) { 18721 composeCodeableReference(t, "RiskAssessment", "reason", element.getReason().get(i), i); 18722 } 18723 for (int i = 0; i < element.getBasis().size(); i++) { 18724 composeReference(t, "RiskAssessment", "basis", element.getBasis().get(i), i); 18725 } 18726 for (int i = 0; i < element.getPrediction().size(); i++) { 18727 composeRiskAssessmentPredictionComponent(t, "RiskAssessment", "prediction", element.getPrediction().get(i), i); 18728 } 18729 if (element.hasMitigationElement()) { 18730 composeString(t, "RiskAssessment", "mitigation", element.getMitigationElement(), -1); 18731 } 18732 for (int i = 0; i < element.getNote().size(); i++) { 18733 composeAnnotation(t, "RiskAssessment", "note", element.getNote().get(i), i); 18734 } 18735 } 18736 18737 protected void composeRiskAssessmentPredictionComponent(Complex parent, String parentType, String name, RiskAssessment.RiskAssessmentPredictionComponent element, int index) { 18738 if (element == null) 18739 return; 18740 Complex t; 18741 if (Utilities.noString(parentType)) 18742 t = parent; 18743 else { 18744 t = parent.predicate("fhir:"+parentType+'.'+name); 18745 } 18746 composeBackboneElement(t, "prediction", name, element, index); 18747 if (element.hasOutcome()) { 18748 composeCodeableConcept(t, "RiskAssessmentPredictionComponent", "outcome", element.getOutcome(), -1); 18749 } 18750 if (element.hasProbability()) { 18751 composeType(t, "RiskAssessmentPredictionComponent", "probability", element.getProbability(), -1); 18752 } 18753 if (element.hasQualitativeRisk()) { 18754 composeCodeableConcept(t, "RiskAssessmentPredictionComponent", "qualitativeRisk", element.getQualitativeRisk(), -1); 18755 } 18756 if (element.hasRelativeRiskElement()) { 18757 composeDecimal(t, "RiskAssessmentPredictionComponent", "relativeRisk", element.getRelativeRiskElement(), -1); 18758 } 18759 if (element.hasWhen()) { 18760 composeType(t, "RiskAssessmentPredictionComponent", "when", element.getWhen(), -1); 18761 } 18762 if (element.hasRationaleElement()) { 18763 composeString(t, "RiskAssessmentPredictionComponent", "rationale", element.getRationaleElement(), -1); 18764 } 18765 } 18766 18767 protected void composeSchedule(Complex parent, String parentType, String name, Schedule element, int index) { 18768 if (element == null) 18769 return; 18770 Complex t; 18771 if (Utilities.noString(parentType)) 18772 t = parent; 18773 else { 18774 t = parent.predicate("fhir:"+parentType+'.'+name); 18775 } 18776 composeDomainResource(t, "Schedule", name, element, index); 18777 for (int i = 0; i < element.getIdentifier().size(); i++) { 18778 composeIdentifier(t, "Schedule", "identifier", element.getIdentifier().get(i), i); 18779 } 18780 if (element.hasActiveElement()) { 18781 composeBoolean(t, "Schedule", "active", element.getActiveElement(), -1); 18782 } 18783 for (int i = 0; i < element.getServiceCategory().size(); i++) { 18784 composeCodeableConcept(t, "Schedule", "serviceCategory", element.getServiceCategory().get(i), i); 18785 } 18786 for (int i = 0; i < element.getServiceType().size(); i++) { 18787 composeCodeableConcept(t, "Schedule", "serviceType", element.getServiceType().get(i), i); 18788 } 18789 for (int i = 0; i < element.getSpecialty().size(); i++) { 18790 composeCodeableConcept(t, "Schedule", "specialty", element.getSpecialty().get(i), i); 18791 } 18792 for (int i = 0; i < element.getActor().size(); i++) { 18793 composeReference(t, "Schedule", "actor", element.getActor().get(i), i); 18794 } 18795 if (element.hasPlanningHorizon()) { 18796 composePeriod(t, "Schedule", "planningHorizon", element.getPlanningHorizon(), -1); 18797 } 18798 if (element.hasCommentElement()) { 18799 composeString(t, "Schedule", "comment", element.getCommentElement(), -1); 18800 } 18801 } 18802 18803 protected void composeSearchParameter(Complex parent, String parentType, String name, SearchParameter element, int index) { 18804 if (element == null) 18805 return; 18806 Complex t; 18807 if (Utilities.noString(parentType)) 18808 t = parent; 18809 else { 18810 t = parent.predicate("fhir:"+parentType+'.'+name); 18811 } 18812 composeCanonicalResource(t, "SearchParameter", name, element, index); 18813 if (element.hasUrlElement()) { 18814 composeUri(t, "SearchParameter", "url", element.getUrlElement(), -1); 18815 } 18816 if (element.hasVersionElement()) { 18817 composeString(t, "SearchParameter", "version", element.getVersionElement(), -1); 18818 } 18819 if (element.hasNameElement()) { 18820 composeString(t, "SearchParameter", "name", element.getNameElement(), -1); 18821 } 18822 if (element.hasDerivedFromElement()) { 18823 composeCanonical(t, "SearchParameter", "derivedFrom", element.getDerivedFromElement(), -1); 18824 } 18825 if (element.hasStatusElement()) { 18826 composeEnum(t, "SearchParameter", "status", element.getStatusElement(), -1); 18827 } 18828 if (element.hasExperimentalElement()) { 18829 composeBoolean(t, "SearchParameter", "experimental", element.getExperimentalElement(), -1); 18830 } 18831 if (element.hasDateElement()) { 18832 composeDateTime(t, "SearchParameter", "date", element.getDateElement(), -1); 18833 } 18834 if (element.hasPublisherElement()) { 18835 composeString(t, "SearchParameter", "publisher", element.getPublisherElement(), -1); 18836 } 18837 for (int i = 0; i < element.getContact().size(); i++) { 18838 composeContactDetail(t, "SearchParameter", "contact", element.getContact().get(i), i); 18839 } 18840 if (element.hasDescriptionElement()) { 18841 composeMarkdown(t, "SearchParameter", "description", element.getDescriptionElement(), -1); 18842 } 18843 for (int i = 0; i < element.getUseContext().size(); i++) { 18844 composeUsageContext(t, "SearchParameter", "useContext", element.getUseContext().get(i), i); 18845 } 18846 for (int i = 0; i < element.getJurisdiction().size(); i++) { 18847 composeCodeableConcept(t, "SearchParameter", "jurisdiction", element.getJurisdiction().get(i), i); 18848 } 18849 if (element.hasPurposeElement()) { 18850 composeMarkdown(t, "SearchParameter", "purpose", element.getPurposeElement(), -1); 18851 } 18852 if (element.hasCodeElement()) { 18853 composeCode(t, "SearchParameter", "code", element.getCodeElement(), -1); 18854 } 18855 for (int i = 0; i < element.getBase().size(); i++) { 18856 composeCode(t, "SearchParameter", "base", element.getBase().get(i), i); 18857 } 18858 if (element.hasTypeElement()) { 18859 composeEnum(t, "SearchParameter", "type", element.getTypeElement(), -1); 18860 } 18861 if (element.hasExpressionElement()) { 18862 composeString(t, "SearchParameter", "expression", element.getExpressionElement(), -1); 18863 } 18864 if (element.hasXpathElement()) { 18865 composeString(t, "SearchParameter", "xpath", element.getXpathElement(), -1); 18866 } 18867 if (element.hasXpathUsageElement()) { 18868 composeEnum(t, "SearchParameter", "xpathUsage", element.getXpathUsageElement(), -1); 18869 } 18870 for (int i = 0; i < element.getTarget().size(); i++) { 18871 composeCode(t, "SearchParameter", "target", element.getTarget().get(i), i); 18872 } 18873 if (element.hasMultipleOrElement()) { 18874 composeBoolean(t, "SearchParameter", "multipleOr", element.getMultipleOrElement(), -1); 18875 } 18876 if (element.hasMultipleAndElement()) { 18877 composeBoolean(t, "SearchParameter", "multipleAnd", element.getMultipleAndElement(), -1); 18878 } 18879 for (int i = 0; i < element.getComparator().size(); i++) { 18880 composeEnum(t, "SearchParameter", "comparator", element.getComparator().get(i), i); 18881 } 18882 for (int i = 0; i < element.getModifier().size(); i++) { 18883 composeEnum(t, "SearchParameter", "modifier", element.getModifier().get(i), i); 18884 } 18885 for (int i = 0; i < element.getChain().size(); i++) { 18886 composeString(t, "SearchParameter", "chain", element.getChain().get(i), i); 18887 } 18888 for (int i = 0; i < element.getComponent().size(); i++) { 18889 composeSearchParameterComponentComponent(t, "SearchParameter", "component", element.getComponent().get(i), i); 18890 } 18891 } 18892 18893 protected void composeSearchParameterComponentComponent(Complex parent, String parentType, String name, SearchParameter.SearchParameterComponentComponent element, int index) { 18894 if (element == null) 18895 return; 18896 Complex t; 18897 if (Utilities.noString(parentType)) 18898 t = parent; 18899 else { 18900 t = parent.predicate("fhir:"+parentType+'.'+name); 18901 } 18902 composeBackboneElement(t, "component", name, element, index); 18903 if (element.hasDefinitionElement()) { 18904 composeCanonical(t, "SearchParameterComponentComponent", "definition", element.getDefinitionElement(), -1); 18905 } 18906 if (element.hasExpressionElement()) { 18907 composeString(t, "SearchParameterComponentComponent", "expression", element.getExpressionElement(), -1); 18908 } 18909 } 18910 18911 protected void composeServiceRequest(Complex parent, String parentType, String name, ServiceRequest element, int index) { 18912 if (element == null) 18913 return; 18914 Complex t; 18915 if (Utilities.noString(parentType)) 18916 t = parent; 18917 else { 18918 t = parent.predicate("fhir:"+parentType+'.'+name); 18919 } 18920 composeDomainResource(t, "ServiceRequest", name, element, index); 18921 for (int i = 0; i < element.getIdentifier().size(); i++) { 18922 composeIdentifier(t, "ServiceRequest", "identifier", element.getIdentifier().get(i), i); 18923 } 18924 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) { 18925 composeCanonical(t, "ServiceRequest", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 18926 } 18927 for (int i = 0; i < element.getInstantiatesUri().size(); i++) { 18928 composeUri(t, "ServiceRequest", "instantiatesUri", element.getInstantiatesUri().get(i), i); 18929 } 18930 for (int i = 0; i < element.getBasedOn().size(); i++) { 18931 composeReference(t, "ServiceRequest", "basedOn", element.getBasedOn().get(i), i); 18932 } 18933 for (int i = 0; i < element.getReplaces().size(); i++) { 18934 composeReference(t, "ServiceRequest", "replaces", element.getReplaces().get(i), i); 18935 } 18936 if (element.hasRequisition()) { 18937 composeIdentifier(t, "ServiceRequest", "requisition", element.getRequisition(), -1); 18938 } 18939 if (element.hasStatusElement()) { 18940 composeEnum(t, "ServiceRequest", "status", element.getStatusElement(), -1); 18941 } 18942 if (element.hasIntentElement()) { 18943 composeEnum(t, "ServiceRequest", "intent", element.getIntentElement(), -1); 18944 } 18945 for (int i = 0; i < element.getCategory().size(); i++) { 18946 composeCodeableConcept(t, "ServiceRequest", "category", element.getCategory().get(i), i); 18947 } 18948 if (element.hasPriorityElement()) { 18949 composeEnum(t, "ServiceRequest", "priority", element.getPriorityElement(), -1); 18950 } 18951 if (element.hasDoNotPerformElement()) { 18952 composeBoolean(t, "ServiceRequest", "doNotPerform", element.getDoNotPerformElement(), -1); 18953 } 18954 if (element.hasCode()) { 18955 composeCodeableConcept(t, "ServiceRequest", "code", element.getCode(), -1); 18956 } 18957 for (int i = 0; i < element.getOrderDetail().size(); i++) { 18958 composeCodeableConcept(t, "ServiceRequest", "orderDetail", element.getOrderDetail().get(i), i); 18959 } 18960 if (element.hasQuantity()) { 18961 composeType(t, "ServiceRequest", "quantity", element.getQuantity(), -1); 18962 } 18963 if (element.hasSubject()) { 18964 composeReference(t, "ServiceRequest", "subject", element.getSubject(), -1); 18965 } 18966 if (element.hasEncounter()) { 18967 composeReference(t, "ServiceRequest", "encounter", element.getEncounter(), -1); 18968 } 18969 if (element.hasOccurrence()) { 18970 composeType(t, "ServiceRequest", "occurrence", element.getOccurrence(), -1); 18971 } 18972 if (element.hasAsNeeded()) { 18973 composeType(t, "ServiceRequest", "asNeeded", element.getAsNeeded(), -1); 18974 } 18975 if (element.hasAuthoredOnElement()) { 18976 composeDateTime(t, "ServiceRequest", "authoredOn", element.getAuthoredOnElement(), -1); 18977 } 18978 if (element.hasRequester()) { 18979 composeReference(t, "ServiceRequest", "requester", element.getRequester(), -1); 18980 } 18981 if (element.hasPerformerType()) { 18982 composeCodeableConcept(t, "ServiceRequest", "performerType", element.getPerformerType(), -1); 18983 } 18984 for (int i = 0; i < element.getPerformer().size(); i++) { 18985 composeReference(t, "ServiceRequest", "performer", element.getPerformer().get(i), i); 18986 } 18987 for (int i = 0; i < element.getLocation().size(); i++) { 18988 composeCodeableReference(t, "ServiceRequest", "location", element.getLocation().get(i), i); 18989 } 18990 for (int i = 0; i < element.getReason().size(); i++) { 18991 composeCodeableReference(t, "ServiceRequest", "reason", element.getReason().get(i), i); 18992 } 18993 for (int i = 0; i < element.getInsurance().size(); i++) { 18994 composeReference(t, "ServiceRequest", "insurance", element.getInsurance().get(i), i); 18995 } 18996 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 18997 composeReference(t, "ServiceRequest", "supportingInfo", element.getSupportingInfo().get(i), i); 18998 } 18999 for (int i = 0; i < element.getSpecimen().size(); i++) { 19000 composeReference(t, "ServiceRequest", "specimen", element.getSpecimen().get(i), i); 19001 } 19002 for (int i = 0; i < element.getBodySite().size(); i++) { 19003 composeCodeableConcept(t, "ServiceRequest", "bodySite", element.getBodySite().get(i), i); 19004 } 19005 for (int i = 0; i < element.getNote().size(); i++) { 19006 composeAnnotation(t, "ServiceRequest", "note", element.getNote().get(i), i); 19007 } 19008 if (element.hasPatientInstructionElement()) { 19009 composeString(t, "ServiceRequest", "patientInstruction", element.getPatientInstructionElement(), -1); 19010 } 19011 for (int i = 0; i < element.getRelevantHistory().size(); i++) { 19012 composeReference(t, "ServiceRequest", "relevantHistory", element.getRelevantHistory().get(i), i); 19013 } 19014 } 19015 19016 protected void composeSlot(Complex parent, String parentType, String name, Slot element, int index) { 19017 if (element == null) 19018 return; 19019 Complex t; 19020 if (Utilities.noString(parentType)) 19021 t = parent; 19022 else { 19023 t = parent.predicate("fhir:"+parentType+'.'+name); 19024 } 19025 composeDomainResource(t, "Slot", name, element, index); 19026 for (int i = 0; i < element.getIdentifier().size(); i++) { 19027 composeIdentifier(t, "Slot", "identifier", element.getIdentifier().get(i), i); 19028 } 19029 for (int i = 0; i < element.getServiceCategory().size(); i++) { 19030 composeCodeableConcept(t, "Slot", "serviceCategory", element.getServiceCategory().get(i), i); 19031 } 19032 for (int i = 0; i < element.getServiceType().size(); i++) { 19033 composeCodeableConcept(t, "Slot", "serviceType", element.getServiceType().get(i), i); 19034 } 19035 for (int i = 0; i < element.getSpecialty().size(); i++) { 19036 composeCodeableConcept(t, "Slot", "specialty", element.getSpecialty().get(i), i); 19037 } 19038 if (element.hasAppointmentType()) { 19039 composeCodeableConcept(t, "Slot", "appointmentType", element.getAppointmentType(), -1); 19040 } 19041 if (element.hasSchedule()) { 19042 composeReference(t, "Slot", "schedule", element.getSchedule(), -1); 19043 } 19044 if (element.hasStatusElement()) { 19045 composeEnum(t, "Slot", "status", element.getStatusElement(), -1); 19046 } 19047 if (element.hasStartElement()) { 19048 composeInstant(t, "Slot", "start", element.getStartElement(), -1); 19049 } 19050 if (element.hasEndElement()) { 19051 composeInstant(t, "Slot", "end", element.getEndElement(), -1); 19052 } 19053 if (element.hasOverbookedElement()) { 19054 composeBoolean(t, "Slot", "overbooked", element.getOverbookedElement(), -1); 19055 } 19056 if (element.hasCommentElement()) { 19057 composeString(t, "Slot", "comment", element.getCommentElement(), -1); 19058 } 19059 } 19060 19061 protected void composeSpecimen(Complex parent, String parentType, String name, Specimen element, int index) { 19062 if (element == null) 19063 return; 19064 Complex t; 19065 if (Utilities.noString(parentType)) 19066 t = parent; 19067 else { 19068 t = parent.predicate("fhir:"+parentType+'.'+name); 19069 } 19070 composeDomainResource(t, "Specimen", name, element, index); 19071 for (int i = 0; i < element.getIdentifier().size(); i++) { 19072 composeIdentifier(t, "Specimen", "identifier", element.getIdentifier().get(i), i); 19073 } 19074 if (element.hasAccessionIdentifier()) { 19075 composeIdentifier(t, "Specimen", "accessionIdentifier", element.getAccessionIdentifier(), -1); 19076 } 19077 if (element.hasStatusElement()) { 19078 composeEnum(t, "Specimen", "status", element.getStatusElement(), -1); 19079 } 19080 if (element.hasType()) { 19081 composeCodeableConcept(t, "Specimen", "type", element.getType(), -1); 19082 } 19083 if (element.hasSubject()) { 19084 composeReference(t, "Specimen", "subject", element.getSubject(), -1); 19085 } 19086 if (element.hasReceivedTimeElement()) { 19087 composeDateTime(t, "Specimen", "receivedTime", element.getReceivedTimeElement(), -1); 19088 } 19089 for (int i = 0; i < element.getParent().size(); i++) { 19090 composeReference(t, "Specimen", "parent", element.getParent().get(i), i); 19091 } 19092 for (int i = 0; i < element.getRequest().size(); i++) { 19093 composeReference(t, "Specimen", "request", element.getRequest().get(i), i); 19094 } 19095 if (element.hasCollection()) { 19096 composeSpecimenCollectionComponent(t, "Specimen", "collection", element.getCollection(), -1); 19097 } 19098 for (int i = 0; i < element.getProcessing().size(); i++) { 19099 composeSpecimenProcessingComponent(t, "Specimen", "processing", element.getProcessing().get(i), i); 19100 } 19101 for (int i = 0; i < element.getContainer().size(); i++) { 19102 composeSpecimenContainerComponent(t, "Specimen", "container", element.getContainer().get(i), i); 19103 } 19104 for (int i = 0; i < element.getCondition().size(); i++) { 19105 composeCodeableConcept(t, "Specimen", "condition", element.getCondition().get(i), i); 19106 } 19107 for (int i = 0; i < element.getNote().size(); i++) { 19108 composeAnnotation(t, "Specimen", "note", element.getNote().get(i), i); 19109 } 19110 } 19111 19112 protected void composeSpecimenCollectionComponent(Complex parent, String parentType, String name, Specimen.SpecimenCollectionComponent element, int index) { 19113 if (element == null) 19114 return; 19115 Complex t; 19116 if (Utilities.noString(parentType)) 19117 t = parent; 19118 else { 19119 t = parent.predicate("fhir:"+parentType+'.'+name); 19120 } 19121 composeBackboneElement(t, "collection", name, element, index); 19122 if (element.hasCollector()) { 19123 composeReference(t, "SpecimenCollectionComponent", "collector", element.getCollector(), -1); 19124 } 19125 if (element.hasCollected()) { 19126 composeType(t, "SpecimenCollectionComponent", "collected", element.getCollected(), -1); 19127 } 19128 if (element.hasDuration()) { 19129 composeDuration(t, "SpecimenCollectionComponent", "duration", element.getDuration(), -1); 19130 } 19131 if (element.hasQuantity()) { 19132 composeQuantity(t, "SpecimenCollectionComponent", "quantity", element.getQuantity(), -1); 19133 } 19134 if (element.hasMethod()) { 19135 composeCodeableConcept(t, "SpecimenCollectionComponent", "method", element.getMethod(), -1); 19136 } 19137 if (element.hasBodySite()) { 19138 composeCodeableConcept(t, "SpecimenCollectionComponent", "bodySite", element.getBodySite(), -1); 19139 } 19140 if (element.hasFastingStatus()) { 19141 composeType(t, "SpecimenCollectionComponent", "fastingStatus", element.getFastingStatus(), -1); 19142 } 19143 } 19144 19145 protected void composeSpecimenProcessingComponent(Complex parent, String parentType, String name, Specimen.SpecimenProcessingComponent element, int index) { 19146 if (element == null) 19147 return; 19148 Complex t; 19149 if (Utilities.noString(parentType)) 19150 t = parent; 19151 else { 19152 t = parent.predicate("fhir:"+parentType+'.'+name); 19153 } 19154 composeBackboneElement(t, "processing", name, element, index); 19155 if (element.hasDescriptionElement()) { 19156 composeString(t, "SpecimenProcessingComponent", "description", element.getDescriptionElement(), -1); 19157 } 19158 if (element.hasProcedure()) { 19159 composeCodeableConcept(t, "SpecimenProcessingComponent", "procedure", element.getProcedure(), -1); 19160 } 19161 for (int i = 0; i < element.getAdditive().size(); i++) { 19162 composeReference(t, "SpecimenProcessingComponent", "additive", element.getAdditive().get(i), i); 19163 } 19164 if (element.hasTime()) { 19165 composeType(t, "SpecimenProcessingComponent", "time", element.getTime(), -1); 19166 } 19167 } 19168 19169 protected void composeSpecimenContainerComponent(Complex parent, String parentType, String name, Specimen.SpecimenContainerComponent element, int index) { 19170 if (element == null) 19171 return; 19172 Complex t; 19173 if (Utilities.noString(parentType)) 19174 t = parent; 19175 else { 19176 t = parent.predicate("fhir:"+parentType+'.'+name); 19177 } 19178 composeBackboneElement(t, "container", name, element, index); 19179 for (int i = 0; i < element.getIdentifier().size(); i++) { 19180 composeIdentifier(t, "SpecimenContainerComponent", "identifier", element.getIdentifier().get(i), i); 19181 } 19182 if (element.hasDescriptionElement()) { 19183 composeString(t, "SpecimenContainerComponent", "description", element.getDescriptionElement(), -1); 19184 } 19185 if (element.hasType()) { 19186 composeCodeableConcept(t, "SpecimenContainerComponent", "type", element.getType(), -1); 19187 } 19188 if (element.hasCapacity()) { 19189 composeQuantity(t, "SpecimenContainerComponent", "capacity", element.getCapacity(), -1); 19190 } 19191 if (element.hasSpecimenQuantity()) { 19192 composeQuantity(t, "SpecimenContainerComponent", "specimenQuantity", element.getSpecimenQuantity(), -1); 19193 } 19194 if (element.hasAdditive()) { 19195 composeType(t, "SpecimenContainerComponent", "additive", element.getAdditive(), -1); 19196 } 19197 } 19198 19199 protected void composeSpecimenDefinition(Complex parent, String parentType, String name, SpecimenDefinition element, int index) { 19200 if (element == null) 19201 return; 19202 Complex t; 19203 if (Utilities.noString(parentType)) 19204 t = parent; 19205 else { 19206 t = parent.predicate("fhir:"+parentType+'.'+name); 19207 } 19208 composeDomainResource(t, "SpecimenDefinition", name, element, index); 19209 if (element.hasUrlElement()) { 19210 composeUri(t, "SpecimenDefinition", "url", element.getUrlElement(), -1); 19211 } 19212 if (element.hasIdentifier()) { 19213 composeIdentifier(t, "SpecimenDefinition", "identifier", element.getIdentifier(), -1); 19214 } 19215 if (element.hasVersionElement()) { 19216 composeString(t, "SpecimenDefinition", "version", element.getVersionElement(), -1); 19217 } 19218 if (element.hasTitleElement()) { 19219 composeString(t, "SpecimenDefinition", "title", element.getTitleElement(), -1); 19220 } 19221 for (int i = 0; i < element.getDerivedFromCanonical().size(); i++) { 19222 composeCanonical(t, "SpecimenDefinition", "derivedFromCanonical", element.getDerivedFromCanonical().get(i), i); 19223 } 19224 for (int i = 0; i < element.getDerivedFromUri().size(); i++) { 19225 composeUri(t, "SpecimenDefinition", "derivedFromUri", element.getDerivedFromUri().get(i), i); 19226 } 19227 if (element.hasStatusElement()) { 19228 composeEnum(t, "SpecimenDefinition", "status", element.getStatusElement(), -1); 19229 } 19230 if (element.hasExperimentalElement()) { 19231 composeBoolean(t, "SpecimenDefinition", "experimental", element.getExperimentalElement(), -1); 19232 } 19233 if (element.hasSubject()) { 19234 composeType(t, "SpecimenDefinition", "subject", element.getSubject(), -1); 19235 } 19236 if (element.hasDateElement()) { 19237 composeDateTime(t, "SpecimenDefinition", "date", element.getDateElement(), -1); 19238 } 19239 if (element.hasPublisher()) { 19240 composeReference(t, "SpecimenDefinition", "publisher", element.getPublisher(), -1); 19241 } 19242 for (int i = 0; i < element.getContact().size(); i++) { 19243 composeContactDetail(t, "SpecimenDefinition", "contact", element.getContact().get(i), i); 19244 } 19245 if (element.hasDescriptionElement()) { 19246 composeMarkdown(t, "SpecimenDefinition", "description", element.getDescriptionElement(), -1); 19247 } 19248 for (int i = 0; i < element.getUseContext().size(); i++) { 19249 composeUsageContext(t, "SpecimenDefinition", "useContext", element.getUseContext().get(i), i); 19250 } 19251 for (int i = 0; i < element.getJurisdiction().size(); i++) { 19252 composeCodeableConcept(t, "SpecimenDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 19253 } 19254 if (element.hasPurposeElement()) { 19255 composeMarkdown(t, "SpecimenDefinition", "purpose", element.getPurposeElement(), -1); 19256 } 19257 if (element.hasCopyrightElement()) { 19258 composeMarkdown(t, "SpecimenDefinition", "copyright", element.getCopyrightElement(), -1); 19259 } 19260 if (element.hasApprovalDateElement()) { 19261 composeDate(t, "SpecimenDefinition", "approvalDate", element.getApprovalDateElement(), -1); 19262 } 19263 if (element.hasLastReviewDateElement()) { 19264 composeDate(t, "SpecimenDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 19265 } 19266 if (element.hasEffectivePeriod()) { 19267 composePeriod(t, "SpecimenDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 19268 } 19269 if (element.hasTypeCollected()) { 19270 composeCodeableConcept(t, "SpecimenDefinition", "typeCollected", element.getTypeCollected(), -1); 19271 } 19272 for (int i = 0; i < element.getPatientPreparation().size(); i++) { 19273 composeCodeableConcept(t, "SpecimenDefinition", "patientPreparation", element.getPatientPreparation().get(i), i); 19274 } 19275 if (element.hasTimeAspectElement()) { 19276 composeString(t, "SpecimenDefinition", "timeAspect", element.getTimeAspectElement(), -1); 19277 } 19278 for (int i = 0; i < element.getCollection().size(); i++) { 19279 composeCodeableConcept(t, "SpecimenDefinition", "collection", element.getCollection().get(i), i); 19280 } 19281 for (int i = 0; i < element.getTypeTested().size(); i++) { 19282 composeSpecimenDefinitionTypeTestedComponent(t, "SpecimenDefinition", "typeTested", element.getTypeTested().get(i), i); 19283 } 19284 } 19285 19286 protected void composeSpecimenDefinitionTypeTestedComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedComponent element, int index) { 19287 if (element == null) 19288 return; 19289 Complex t; 19290 if (Utilities.noString(parentType)) 19291 t = parent; 19292 else { 19293 t = parent.predicate("fhir:"+parentType+'.'+name); 19294 } 19295 composeBackboneElement(t, "typeTested", name, element, index); 19296 if (element.hasIsDerivedElement()) { 19297 composeBoolean(t, "SpecimenDefinitionTypeTestedComponent", "isDerived", element.getIsDerivedElement(), -1); 19298 } 19299 if (element.hasType()) { 19300 composeCodeableConcept(t, "SpecimenDefinitionTypeTestedComponent", "type", element.getType(), -1); 19301 } 19302 if (element.hasPreferenceElement()) { 19303 composeEnum(t, "SpecimenDefinitionTypeTestedComponent", "preference", element.getPreferenceElement(), -1); 19304 } 19305 if (element.hasContainer()) { 19306 composeSpecimenDefinitionTypeTestedContainerComponent(t, "SpecimenDefinitionTypeTestedComponent", "container", element.getContainer(), -1); 19307 } 19308 if (element.hasRequirementElement()) { 19309 composeString(t, "SpecimenDefinitionTypeTestedComponent", "requirement", element.getRequirementElement(), -1); 19310 } 19311 if (element.hasRetentionTime()) { 19312 composeDuration(t, "SpecimenDefinitionTypeTestedComponent", "retentionTime", element.getRetentionTime(), -1); 19313 } 19314 if (element.hasSingleUseElement()) { 19315 composeBoolean(t, "SpecimenDefinitionTypeTestedComponent", "singleUse", element.getSingleUseElement(), -1); 19316 } 19317 for (int i = 0; i < element.getRejectionCriterion().size(); i++) { 19318 composeCodeableConcept(t, "SpecimenDefinitionTypeTestedComponent", "rejectionCriterion", element.getRejectionCriterion().get(i), i); 19319 } 19320 for (int i = 0; i < element.getHandling().size(); i++) { 19321 composeSpecimenDefinitionTypeTestedHandlingComponent(t, "SpecimenDefinitionTypeTestedComponent", "handling", element.getHandling().get(i), i); 19322 } 19323 for (int i = 0; i < element.getTestingDestination().size(); i++) { 19324 composeCodeableConcept(t, "SpecimenDefinitionTypeTestedComponent", "testingDestination", element.getTestingDestination().get(i), i); 19325 } 19326 } 19327 19328 protected void composeSpecimenDefinitionTypeTestedContainerComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedContainerComponent element, int index) { 19329 if (element == null) 19330 return; 19331 Complex t; 19332 if (Utilities.noString(parentType)) 19333 t = parent; 19334 else { 19335 t = parent.predicate("fhir:"+parentType+'.'+name); 19336 } 19337 composeBackboneElement(t, "container", name, element, index); 19338 if (element.hasMaterial()) { 19339 composeCodeableConcept(t, "SpecimenDefinitionTypeTestedContainerComponent", "material", element.getMaterial(), -1); 19340 } 19341 if (element.hasType()) { 19342 composeCodeableConcept(t, "SpecimenDefinitionTypeTestedContainerComponent", "type", element.getType(), -1); 19343 } 19344 if (element.hasCap()) { 19345 composeCodeableConcept(t, "SpecimenDefinitionTypeTestedContainerComponent", "cap", element.getCap(), -1); 19346 } 19347 if (element.hasDescriptionElement()) { 19348 composeString(t, "SpecimenDefinitionTypeTestedContainerComponent", "description", element.getDescriptionElement(), -1); 19349 } 19350 if (element.hasCapacity()) { 19351 composeQuantity(t, "SpecimenDefinitionTypeTestedContainerComponent", "capacity", element.getCapacity(), -1); 19352 } 19353 if (element.hasMinimumVolume()) { 19354 composeType(t, "SpecimenDefinitionTypeTestedContainerComponent", "minimumVolume", element.getMinimumVolume(), -1); 19355 } 19356 for (int i = 0; i < element.getAdditive().size(); i++) { 19357 composeSpecimenDefinitionTypeTestedContainerAdditiveComponent(t, "SpecimenDefinitionTypeTestedContainerComponent", "additive", element.getAdditive().get(i), i); 19358 } 19359 if (element.hasPreparationElement()) { 19360 composeString(t, "SpecimenDefinitionTypeTestedContainerComponent", "preparation", element.getPreparationElement(), -1); 19361 } 19362 } 19363 19364 protected void composeSpecimenDefinitionTypeTestedContainerAdditiveComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedContainerAdditiveComponent element, int index) { 19365 if (element == null) 19366 return; 19367 Complex t; 19368 if (Utilities.noString(parentType)) 19369 t = parent; 19370 else { 19371 t = parent.predicate("fhir:"+parentType+'.'+name); 19372 } 19373 composeBackboneElement(t, "additive", name, element, index); 19374 if (element.hasAdditive()) { 19375 composeType(t, "SpecimenDefinitionTypeTestedContainerAdditiveComponent", "additive", element.getAdditive(), -1); 19376 } 19377 } 19378 19379 protected void composeSpecimenDefinitionTypeTestedHandlingComponent(Complex parent, String parentType, String name, SpecimenDefinition.SpecimenDefinitionTypeTestedHandlingComponent element, int index) { 19380 if (element == null) 19381 return; 19382 Complex t; 19383 if (Utilities.noString(parentType)) 19384 t = parent; 19385 else { 19386 t = parent.predicate("fhir:"+parentType+'.'+name); 19387 } 19388 composeBackboneElement(t, "handling", name, element, index); 19389 if (element.hasTemperatureQualifier()) { 19390 composeCodeableConcept(t, "SpecimenDefinitionTypeTestedHandlingComponent", "temperatureQualifier", element.getTemperatureQualifier(), -1); 19391 } 19392 if (element.hasTemperatureRange()) { 19393 composeRange(t, "SpecimenDefinitionTypeTestedHandlingComponent", "temperatureRange", element.getTemperatureRange(), -1); 19394 } 19395 if (element.hasMaxDuration()) { 19396 composeDuration(t, "SpecimenDefinitionTypeTestedHandlingComponent", "maxDuration", element.getMaxDuration(), -1); 19397 } 19398 if (element.hasInstructionElement()) { 19399 composeString(t, "SpecimenDefinitionTypeTestedHandlingComponent", "instruction", element.getInstructionElement(), -1); 19400 } 19401 } 19402 19403 protected void composeStructureDefinition(Complex parent, String parentType, String name, StructureDefinition element, int index) { 19404 if (element == null) 19405 return; 19406 Complex t; 19407 if (Utilities.noString(parentType)) 19408 t = parent; 19409 else { 19410 t = parent.predicate("fhir:"+parentType+'.'+name); 19411 } 19412 composeCanonicalResource(t, "StructureDefinition", name, element, index); 19413 if (element.hasUrlElement()) { 19414 composeUri(t, "StructureDefinition", "url", element.getUrlElement(), -1); 19415 } 19416 for (int i = 0; i < element.getIdentifier().size(); i++) { 19417 composeIdentifier(t, "StructureDefinition", "identifier", element.getIdentifier().get(i), i); 19418 } 19419 if (element.hasVersionElement()) { 19420 composeString(t, "StructureDefinition", "version", element.getVersionElement(), -1); 19421 } 19422 if (element.hasNameElement()) { 19423 composeString(t, "StructureDefinition", "name", element.getNameElement(), -1); 19424 } 19425 if (element.hasTitleElement()) { 19426 composeString(t, "StructureDefinition", "title", element.getTitleElement(), -1); 19427 } 19428 if (element.hasStatusElement()) { 19429 composeEnum(t, "StructureDefinition", "status", element.getStatusElement(), -1); 19430 } 19431 if (element.hasExperimentalElement()) { 19432 composeBoolean(t, "StructureDefinition", "experimental", element.getExperimentalElement(), -1); 19433 } 19434 if (element.hasDateElement()) { 19435 composeDateTime(t, "StructureDefinition", "date", element.getDateElement(), -1); 19436 } 19437 if (element.hasPublisherElement()) { 19438 composeString(t, "StructureDefinition", "publisher", element.getPublisherElement(), -1); 19439 } 19440 for (int i = 0; i < element.getContact().size(); i++) { 19441 composeContactDetail(t, "StructureDefinition", "contact", element.getContact().get(i), i); 19442 } 19443 if (element.hasDescriptionElement()) { 19444 composeMarkdown(t, "StructureDefinition", "description", element.getDescriptionElement(), -1); 19445 } 19446 for (int i = 0; i < element.getUseContext().size(); i++) { 19447 composeUsageContext(t, "StructureDefinition", "useContext", element.getUseContext().get(i), i); 19448 } 19449 for (int i = 0; i < element.getJurisdiction().size(); i++) { 19450 composeCodeableConcept(t, "StructureDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 19451 } 19452 if (element.hasPurposeElement()) { 19453 composeMarkdown(t, "StructureDefinition", "purpose", element.getPurposeElement(), -1); 19454 } 19455 if (element.hasCopyrightElement()) { 19456 composeMarkdown(t, "StructureDefinition", "copyright", element.getCopyrightElement(), -1); 19457 } 19458 for (int i = 0; i < element.getKeyword().size(); i++) { 19459 composeCoding(t, "StructureDefinition", "keyword", element.getKeyword().get(i), i); 19460 } 19461 if (element.hasFhirVersionElement()) { 19462 composeEnum(t, "StructureDefinition", "fhirVersion", element.getFhirVersionElement(), -1); 19463 } 19464 for (int i = 0; i < element.getMapping().size(); i++) { 19465 composeStructureDefinitionMappingComponent(t, "StructureDefinition", "mapping", element.getMapping().get(i), i); 19466 } 19467 if (element.hasKindElement()) { 19468 composeEnum(t, "StructureDefinition", "kind", element.getKindElement(), -1); 19469 } 19470 if (element.hasAbstractElement()) { 19471 composeBoolean(t, "StructureDefinition", "abstract", element.getAbstractElement(), -1); 19472 } 19473 for (int i = 0; i < element.getContext().size(); i++) { 19474 composeStructureDefinitionContextComponent(t, "StructureDefinition", "context", element.getContext().get(i), i); 19475 } 19476 for (int i = 0; i < element.getContextInvariant().size(); i++) { 19477 composeString(t, "StructureDefinition", "contextInvariant", element.getContextInvariant().get(i), i); 19478 } 19479 if (element.hasTypeElement()) { 19480 composeUri(t, "StructureDefinition", "type", element.getTypeElement(), -1); 19481 } 19482 if (element.hasBaseDefinitionElement()) { 19483 composeCanonical(t, "StructureDefinition", "baseDefinition", element.getBaseDefinitionElement(), -1); 19484 } 19485 if (element.hasDerivationElement()) { 19486 composeEnum(t, "StructureDefinition", "derivation", element.getDerivationElement(), -1); 19487 } 19488 if (element.hasSnapshot()) { 19489 composeStructureDefinitionSnapshotComponent(t, "StructureDefinition", "snapshot", element.getSnapshot(), -1); 19490 } 19491 if (element.hasDifferential()) { 19492 composeStructureDefinitionDifferentialComponent(t, "StructureDefinition", "differential", element.getDifferential(), -1); 19493 } 19494 } 19495 19496 protected void composeStructureDefinitionMappingComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionMappingComponent element, int index) { 19497 if (element == null) 19498 return; 19499 Complex t; 19500 if (Utilities.noString(parentType)) 19501 t = parent; 19502 else { 19503 t = parent.predicate("fhir:"+parentType+'.'+name); 19504 } 19505 composeBackboneElement(t, "mapping", name, element, index); 19506 if (element.hasIdentityElement()) { 19507 composeId(t, "StructureDefinitionMappingComponent", "identity", element.getIdentityElement(), -1); 19508 } 19509 if (element.hasUriElement()) { 19510 composeUri(t, "StructureDefinitionMappingComponent", "uri", element.getUriElement(), -1); 19511 } 19512 if (element.hasNameElement()) { 19513 composeString(t, "StructureDefinitionMappingComponent", "name", element.getNameElement(), -1); 19514 } 19515 if (element.hasCommentElement()) { 19516 composeString(t, "StructureDefinitionMappingComponent", "comment", element.getCommentElement(), -1); 19517 } 19518 } 19519 19520 protected void composeStructureDefinitionContextComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionContextComponent element, int index) { 19521 if (element == null) 19522 return; 19523 Complex t; 19524 if (Utilities.noString(parentType)) 19525 t = parent; 19526 else { 19527 t = parent.predicate("fhir:"+parentType+'.'+name); 19528 } 19529 composeBackboneElement(t, "context", name, element, index); 19530 if (element.hasTypeElement()) { 19531 composeEnum(t, "StructureDefinitionContextComponent", "type", element.getTypeElement(), -1); 19532 } 19533 if (element.hasExpressionElement()) { 19534 composeString(t, "StructureDefinitionContextComponent", "expression", element.getExpressionElement(), -1); 19535 } 19536 } 19537 19538 protected void composeStructureDefinitionSnapshotComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionSnapshotComponent element, int index) { 19539 if (element == null) 19540 return; 19541 Complex t; 19542 if (Utilities.noString(parentType)) 19543 t = parent; 19544 else { 19545 t = parent.predicate("fhir:"+parentType+'.'+name); 19546 } 19547 composeBackboneElement(t, "snapshot", name, element, index); 19548 for (int i = 0; i < element.getElement().size(); i++) { 19549 composeElementDefinition(t, "StructureDefinitionSnapshotComponent", "element", element.getElement().get(i), i); 19550 } 19551 } 19552 19553 protected void composeStructureDefinitionDifferentialComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionDifferentialComponent element, int index) { 19554 if (element == null) 19555 return; 19556 Complex t; 19557 if (Utilities.noString(parentType)) 19558 t = parent; 19559 else { 19560 t = parent.predicate("fhir:"+parentType+'.'+name); 19561 } 19562 composeBackboneElement(t, "differential", name, element, index); 19563 for (int i = 0; i < element.getElement().size(); i++) { 19564 composeElementDefinition(t, "StructureDefinitionDifferentialComponent", "element", element.getElement().get(i), i); 19565 } 19566 } 19567 19568 protected void composeStructureMap(Complex parent, String parentType, String name, StructureMap element, int index) { 19569 if (element == null) 19570 return; 19571 Complex t; 19572 if (Utilities.noString(parentType)) 19573 t = parent; 19574 else { 19575 t = parent.predicate("fhir:"+parentType+'.'+name); 19576 } 19577 composeCanonicalResource(t, "StructureMap", name, element, index); 19578 if (element.hasUrlElement()) { 19579 composeUri(t, "StructureMap", "url", element.getUrlElement(), -1); 19580 } 19581 for (int i = 0; i < element.getIdentifier().size(); i++) { 19582 composeIdentifier(t, "StructureMap", "identifier", element.getIdentifier().get(i), i); 19583 } 19584 if (element.hasVersionElement()) { 19585 composeString(t, "StructureMap", "version", element.getVersionElement(), -1); 19586 } 19587 if (element.hasNameElement()) { 19588 composeString(t, "StructureMap", "name", element.getNameElement(), -1); 19589 } 19590 if (element.hasTitleElement()) { 19591 composeString(t, "StructureMap", "title", element.getTitleElement(), -1); 19592 } 19593 if (element.hasStatusElement()) { 19594 composeEnum(t, "StructureMap", "status", element.getStatusElement(), -1); 19595 } 19596 if (element.hasExperimentalElement()) { 19597 composeBoolean(t, "StructureMap", "experimental", element.getExperimentalElement(), -1); 19598 } 19599 if (element.hasDateElement()) { 19600 composeDateTime(t, "StructureMap", "date", element.getDateElement(), -1); 19601 } 19602 if (element.hasPublisherElement()) { 19603 composeString(t, "StructureMap", "publisher", element.getPublisherElement(), -1); 19604 } 19605 for (int i = 0; i < element.getContact().size(); i++) { 19606 composeContactDetail(t, "StructureMap", "contact", element.getContact().get(i), i); 19607 } 19608 if (element.hasDescriptionElement()) { 19609 composeMarkdown(t, "StructureMap", "description", element.getDescriptionElement(), -1); 19610 } 19611 for (int i = 0; i < element.getUseContext().size(); i++) { 19612 composeUsageContext(t, "StructureMap", "useContext", element.getUseContext().get(i), i); 19613 } 19614 for (int i = 0; i < element.getJurisdiction().size(); i++) { 19615 composeCodeableConcept(t, "StructureMap", "jurisdiction", element.getJurisdiction().get(i), i); 19616 } 19617 if (element.hasPurposeElement()) { 19618 composeMarkdown(t, "StructureMap", "purpose", element.getPurposeElement(), -1); 19619 } 19620 if (element.hasCopyrightElement()) { 19621 composeMarkdown(t, "StructureMap", "copyright", element.getCopyrightElement(), -1); 19622 } 19623 for (int i = 0; i < element.getStructure().size(); i++) { 19624 composeStructureMapStructureComponent(t, "StructureMap", "structure", element.getStructure().get(i), i); 19625 } 19626 for (int i = 0; i < element.getImport().size(); i++) { 19627 composeCanonical(t, "StructureMap", "import", element.getImport().get(i), i); 19628 } 19629 for (int i = 0; i < element.getGroup().size(); i++) { 19630 composeStructureMapGroupComponent(t, "StructureMap", "group", element.getGroup().get(i), i); 19631 } 19632 } 19633 19634 protected void composeStructureMapStructureComponent(Complex parent, String parentType, String name, StructureMap.StructureMapStructureComponent element, int index) { 19635 if (element == null) 19636 return; 19637 Complex t; 19638 if (Utilities.noString(parentType)) 19639 t = parent; 19640 else { 19641 t = parent.predicate("fhir:"+parentType+'.'+name); 19642 } 19643 composeBackboneElement(t, "structure", name, element, index); 19644 if (element.hasUrlElement()) { 19645 composeCanonical(t, "StructureMapStructureComponent", "url", element.getUrlElement(), -1); 19646 } 19647 if (element.hasModeElement()) { 19648 composeEnum(t, "StructureMapStructureComponent", "mode", element.getModeElement(), -1); 19649 } 19650 if (element.hasAliasElement()) { 19651 composeString(t, "StructureMapStructureComponent", "alias", element.getAliasElement(), -1); 19652 } 19653 if (element.hasDocumentationElement()) { 19654 composeString(t, "StructureMapStructureComponent", "documentation", element.getDocumentationElement(), -1); 19655 } 19656 } 19657 19658 protected void composeStructureMapGroupComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupComponent element, int index) { 19659 if (element == null) 19660 return; 19661 Complex t; 19662 if (Utilities.noString(parentType)) 19663 t = parent; 19664 else { 19665 t = parent.predicate("fhir:"+parentType+'.'+name); 19666 } 19667 composeBackboneElement(t, "group", name, element, index); 19668 if (element.hasNameElement()) { 19669 composeId(t, "StructureMapGroupComponent", "name", element.getNameElement(), -1); 19670 } 19671 if (element.hasExtendsElement()) { 19672 composeId(t, "StructureMapGroupComponent", "extends", element.getExtendsElement(), -1); 19673 } 19674 if (element.hasTypeModeElement()) { 19675 composeEnum(t, "StructureMapGroupComponent", "typeMode", element.getTypeModeElement(), -1); 19676 } 19677 if (element.hasDocumentationElement()) { 19678 composeString(t, "StructureMapGroupComponent", "documentation", element.getDocumentationElement(), -1); 19679 } 19680 for (int i = 0; i < element.getInput().size(); i++) { 19681 composeStructureMapGroupInputComponent(t, "StructureMapGroupComponent", "input", element.getInput().get(i), i); 19682 } 19683 for (int i = 0; i < element.getRule().size(); i++) { 19684 composeStructureMapGroupRuleComponent(t, "StructureMapGroupComponent", "rule", element.getRule().get(i), i); 19685 } 19686 } 19687 19688 protected void composeStructureMapGroupInputComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupInputComponent element, int index) { 19689 if (element == null) 19690 return; 19691 Complex t; 19692 if (Utilities.noString(parentType)) 19693 t = parent; 19694 else { 19695 t = parent.predicate("fhir:"+parentType+'.'+name); 19696 } 19697 composeBackboneElement(t, "input", name, element, index); 19698 if (element.hasNameElement()) { 19699 composeId(t, "StructureMapGroupInputComponent", "name", element.getNameElement(), -1); 19700 } 19701 if (element.hasTypeElement()) { 19702 composeString(t, "StructureMapGroupInputComponent", "type", element.getTypeElement(), -1); 19703 } 19704 if (element.hasModeElement()) { 19705 composeEnum(t, "StructureMapGroupInputComponent", "mode", element.getModeElement(), -1); 19706 } 19707 if (element.hasDocumentationElement()) { 19708 composeString(t, "StructureMapGroupInputComponent", "documentation", element.getDocumentationElement(), -1); 19709 } 19710 } 19711 19712 protected void composeStructureMapGroupRuleComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleComponent element, int index) { 19713 if (element == null) 19714 return; 19715 Complex t; 19716 if (Utilities.noString(parentType)) 19717 t = parent; 19718 else { 19719 t = parent.predicate("fhir:"+parentType+'.'+name); 19720 } 19721 composeBackboneElement(t, "rule", name, element, index); 19722 if (element.hasNameElement()) { 19723 composeId(t, "StructureMapGroupRuleComponent", "name", element.getNameElement(), -1); 19724 } 19725 for (int i = 0; i < element.getSource().size(); i++) { 19726 composeStructureMapGroupRuleSourceComponent(t, "StructureMapGroupRuleComponent", "source", element.getSource().get(i), i); 19727 } 19728 for (int i = 0; i < element.getTarget().size(); i++) { 19729 composeStructureMapGroupRuleTargetComponent(t, "StructureMapGroupRuleComponent", "target", element.getTarget().get(i), i); 19730 } 19731 for (int i = 0; i < element.getRule().size(); i++) { 19732 composeStructureMapGroupRuleComponent(t, "StructureMapGroupRuleComponent", "rule", element.getRule().get(i), i); 19733 } 19734 for (int i = 0; i < element.getDependent().size(); i++) { 19735 composeStructureMapGroupRuleDependentComponent(t, "StructureMapGroupRuleComponent", "dependent", element.getDependent().get(i), i); 19736 } 19737 if (element.hasDocumentationElement()) { 19738 composeString(t, "StructureMapGroupRuleComponent", "documentation", element.getDocumentationElement(), -1); 19739 } 19740 } 19741 19742 protected void composeStructureMapGroupRuleSourceComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleSourceComponent element, int index) { 19743 if (element == null) 19744 return; 19745 Complex t; 19746 if (Utilities.noString(parentType)) 19747 t = parent; 19748 else { 19749 t = parent.predicate("fhir:"+parentType+'.'+name); 19750 } 19751 composeBackboneElement(t, "source", name, element, index); 19752 if (element.hasContextElement()) { 19753 composeId(t, "StructureMapGroupRuleSourceComponent", "context", element.getContextElement(), -1); 19754 } 19755 if (element.hasMinElement()) { 19756 composeInteger(t, "StructureMapGroupRuleSourceComponent", "min", element.getMinElement(), -1); 19757 } 19758 if (element.hasMaxElement()) { 19759 composeString(t, "StructureMapGroupRuleSourceComponent", "max", element.getMaxElement(), -1); 19760 } 19761 if (element.hasTypeElement()) { 19762 composeString(t, "StructureMapGroupRuleSourceComponent", "type", element.getTypeElement(), -1); 19763 } 19764 if (element.hasDefaultValue()) { 19765 composeType(t, "StructureMapGroupRuleSourceComponent", "defaultValue", element.getDefaultValue(), -1); 19766 } 19767 if (element.hasElementElement()) { 19768 composeString(t, "StructureMapGroupRuleSourceComponent", "element", element.getElementElement(), -1); 19769 } 19770 if (element.hasListModeElement()) { 19771 composeEnum(t, "StructureMapGroupRuleSourceComponent", "listMode", element.getListModeElement(), -1); 19772 } 19773 if (element.hasVariableElement()) { 19774 composeId(t, "StructureMapGroupRuleSourceComponent", "variable", element.getVariableElement(), -1); 19775 } 19776 if (element.hasConditionElement()) { 19777 composeString(t, "StructureMapGroupRuleSourceComponent", "condition", element.getConditionElement(), -1); 19778 } 19779 if (element.hasCheckElement()) { 19780 composeString(t, "StructureMapGroupRuleSourceComponent", "check", element.getCheckElement(), -1); 19781 } 19782 if (element.hasLogMessageElement()) { 19783 composeString(t, "StructureMapGroupRuleSourceComponent", "logMessage", element.getLogMessageElement(), -1); 19784 } 19785 } 19786 19787 protected void composeStructureMapGroupRuleTargetComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetComponent element, int index) { 19788 if (element == null) 19789 return; 19790 Complex t; 19791 if (Utilities.noString(parentType)) 19792 t = parent; 19793 else { 19794 t = parent.predicate("fhir:"+parentType+'.'+name); 19795 } 19796 composeBackboneElement(t, "target", name, element, index); 19797 if (element.hasContextElement()) { 19798 composeId(t, "StructureMapGroupRuleTargetComponent", "context", element.getContextElement(), -1); 19799 } 19800 if (element.hasContextTypeElement()) { 19801 composeEnum(t, "StructureMapGroupRuleTargetComponent", "contextType", element.getContextTypeElement(), -1); 19802 } 19803 if (element.hasElementElement()) { 19804 composeString(t, "StructureMapGroupRuleTargetComponent", "element", element.getElementElement(), -1); 19805 } 19806 if (element.hasVariableElement()) { 19807 composeId(t, "StructureMapGroupRuleTargetComponent", "variable", element.getVariableElement(), -1); 19808 } 19809 for (int i = 0; i < element.getListMode().size(); i++) { 19810 composeEnum(t, "StructureMapGroupRuleTargetComponent", "listMode", element.getListMode().get(i), i); 19811 } 19812 if (element.hasListRuleIdElement()) { 19813 composeId(t, "StructureMapGroupRuleTargetComponent", "listRuleId", element.getListRuleIdElement(), -1); 19814 } 19815 if (element.hasTransformElement()) { 19816 composeEnum(t, "StructureMapGroupRuleTargetComponent", "transform", element.getTransformElement(), -1); 19817 } 19818 for (int i = 0; i < element.getParameter().size(); i++) { 19819 composeStructureMapGroupRuleTargetParameterComponent(t, "StructureMapGroupRuleTargetComponent", "parameter", element.getParameter().get(i), i); 19820 } 19821 } 19822 19823 protected void composeStructureMapGroupRuleTargetParameterComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetParameterComponent element, int index) { 19824 if (element == null) 19825 return; 19826 Complex t; 19827 if (Utilities.noString(parentType)) 19828 t = parent; 19829 else { 19830 t = parent.predicate("fhir:"+parentType+'.'+name); 19831 } 19832 composeBackboneElement(t, "parameter", name, element, index); 19833 if (element.hasValue()) { 19834 composeType(t, "StructureMapGroupRuleTargetParameterComponent", "value", element.getValue(), -1); 19835 } 19836 } 19837 19838 protected void composeStructureMapGroupRuleDependentComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleDependentComponent element, int index) { 19839 if (element == null) 19840 return; 19841 Complex t; 19842 if (Utilities.noString(parentType)) 19843 t = parent; 19844 else { 19845 t = parent.predicate("fhir:"+parentType+'.'+name); 19846 } 19847 composeBackboneElement(t, "dependent", name, element, index); 19848 if (element.hasNameElement()) { 19849 composeId(t, "StructureMapGroupRuleDependentComponent", "name", element.getNameElement(), -1); 19850 } 19851 for (int i = 0; i < element.getVariable().size(); i++) { 19852 composeString(t, "StructureMapGroupRuleDependentComponent", "variable", element.getVariable().get(i), i); 19853 } 19854 } 19855 19856 protected void composeSubscription(Complex parent, String parentType, String name, Subscription element, int index) { 19857 if (element == null) 19858 return; 19859 Complex t; 19860 if (Utilities.noString(parentType)) 19861 t = parent; 19862 else { 19863 t = parent.predicate("fhir:"+parentType+'.'+name); 19864 } 19865 composeDomainResource(t, "Subscription", name, element, index); 19866 for (int i = 0; i < element.getIdentifier().size(); i++) { 19867 composeIdentifier(t, "Subscription", "identifier", element.getIdentifier().get(i), i); 19868 } 19869 if (element.hasNameElement()) { 19870 composeString(t, "Subscription", "name", element.getNameElement(), -1); 19871 } 19872 if (element.hasStatusElement()) { 19873 composeEnum(t, "Subscription", "status", element.getStatusElement(), -1); 19874 } 19875 if (element.hasTopic()) { 19876 composeReference(t, "Subscription", "topic", element.getTopic(), -1); 19877 } 19878 for (int i = 0; i < element.getContact().size(); i++) { 19879 composeContactPoint(t, "Subscription", "contact", element.getContact().get(i), i); 19880 } 19881 if (element.hasEndElement()) { 19882 composeInstant(t, "Subscription", "end", element.getEndElement(), -1); 19883 } 19884 if (element.hasReasonElement()) { 19885 composeString(t, "Subscription", "reason", element.getReasonElement(), -1); 19886 } 19887 for (int i = 0; i < element.getFilterBy().size(); i++) { 19888 composeSubscriptionFilterByComponent(t, "Subscription", "filterBy", element.getFilterBy().get(i), i); 19889 } 19890 for (int i = 0; i < element.getError().size(); i++) { 19891 composeCodeableConcept(t, "Subscription", "error", element.getError().get(i), i); 19892 } 19893 if (element.hasEventCountElement()) { 19894 composeUnsignedInt(t, "Subscription", "eventCount", element.getEventCountElement(), -1); 19895 } 19896 if (element.hasChannel()) { 19897 composeSubscriptionChannelComponent(t, "Subscription", "channel", element.getChannel(), -1); 19898 } 19899 } 19900 19901 protected void composeSubscriptionFilterByComponent(Complex parent, String parentType, String name, Subscription.SubscriptionFilterByComponent element, int index) { 19902 if (element == null) 19903 return; 19904 Complex t; 19905 if (Utilities.noString(parentType)) 19906 t = parent; 19907 else { 19908 t = parent.predicate("fhir:"+parentType+'.'+name); 19909 } 19910 composeBackboneElement(t, "filterBy", name, element, index); 19911 if (element.hasNameElement()) { 19912 composeString(t, "SubscriptionFilterByComponent", "name", element.getNameElement(), -1); 19913 } 19914 if (element.hasMatchTypeElement()) { 19915 composeEnum(t, "SubscriptionFilterByComponent", "matchType", element.getMatchTypeElement(), -1); 19916 } 19917 if (element.hasValueElement()) { 19918 composeString(t, "SubscriptionFilterByComponent", "value", element.getValueElement(), -1); 19919 } 19920 } 19921 19922 protected void composeSubscriptionChannelComponent(Complex parent, String parentType, String name, Subscription.SubscriptionChannelComponent element, int index) { 19923 if (element == null) 19924 return; 19925 Complex t; 19926 if (Utilities.noString(parentType)) 19927 t = parent; 19928 else { 19929 t = parent.predicate("fhir:"+parentType+'.'+name); 19930 } 19931 composeBackboneElement(t, "channel", name, element, index); 19932 if (element.hasType()) { 19933 composeCodeableConcept(t, "SubscriptionChannelComponent", "type", element.getType(), -1); 19934 } 19935 if (element.hasEndpointElement()) { 19936 composeUrl(t, "SubscriptionChannelComponent", "endpoint", element.getEndpointElement(), -1); 19937 } 19938 for (int i = 0; i < element.getHeader().size(); i++) { 19939 composeString(t, "SubscriptionChannelComponent", "header", element.getHeader().get(i), i); 19940 } 19941 if (element.hasHeartbeatPeriodElement()) { 19942 composeUnsignedInt(t, "SubscriptionChannelComponent", "heartbeatPeriod", element.getHeartbeatPeriodElement(), -1); 19943 } 19944 if (element.hasPayload()) { 19945 composeSubscriptionChannelPayloadComponent(t, "SubscriptionChannelComponent", "payload", element.getPayload(), -1); 19946 } 19947 } 19948 19949 protected void composeSubscriptionChannelPayloadComponent(Complex parent, String parentType, String name, Subscription.SubscriptionChannelPayloadComponent element, int index) { 19950 if (element == null) 19951 return; 19952 Complex t; 19953 if (Utilities.noString(parentType)) 19954 t = parent; 19955 else { 19956 t = parent.predicate("fhir:"+parentType+'.'+name); 19957 } 19958 composeBackboneElement(t, "payload", name, element, index); 19959 if (element.hasContentTypeElement()) { 19960 composeCode(t, "SubscriptionChannelPayloadComponent", "contentType", element.getContentTypeElement(), -1); 19961 } 19962 if (element.hasContentElement()) { 19963 composeEnum(t, "SubscriptionChannelPayloadComponent", "content", element.getContentElement(), -1); 19964 } 19965 } 19966 19967 protected void composeSubstance(Complex parent, String parentType, String name, Substance element, int index) { 19968 if (element == null) 19969 return; 19970 Complex t; 19971 if (Utilities.noString(parentType)) 19972 t = parent; 19973 else { 19974 t = parent.predicate("fhir:"+parentType+'.'+name); 19975 } 19976 composeDomainResource(t, "Substance", name, element, index); 19977 for (int i = 0; i < element.getIdentifier().size(); i++) { 19978 composeIdentifier(t, "Substance", "identifier", element.getIdentifier().get(i), i); 19979 } 19980 if (element.hasStatusElement()) { 19981 composeEnum(t, "Substance", "status", element.getStatusElement(), -1); 19982 } 19983 for (int i = 0; i < element.getCategory().size(); i++) { 19984 composeCodeableConcept(t, "Substance", "category", element.getCategory().get(i), i); 19985 } 19986 if (element.hasCode()) { 19987 composeCodeableConcept(t, "Substance", "code", element.getCode(), -1); 19988 } 19989 if (element.hasDescriptionElement()) { 19990 composeString(t, "Substance", "description", element.getDescriptionElement(), -1); 19991 } 19992 for (int i = 0; i < element.getInstance().size(); i++) { 19993 composeSubstanceInstanceComponent(t, "Substance", "instance", element.getInstance().get(i), i); 19994 } 19995 for (int i = 0; i < element.getIngredient().size(); i++) { 19996 composeSubstanceIngredientComponent(t, "Substance", "ingredient", element.getIngredient().get(i), i); 19997 } 19998 } 19999 20000 protected void composeSubstanceInstanceComponent(Complex parent, String parentType, String name, Substance.SubstanceInstanceComponent element, int index) { 20001 if (element == null) 20002 return; 20003 Complex t; 20004 if (Utilities.noString(parentType)) 20005 t = parent; 20006 else { 20007 t = parent.predicate("fhir:"+parentType+'.'+name); 20008 } 20009 composeBackboneElement(t, "instance", name, element, index); 20010 if (element.hasIdentifier()) { 20011 composeIdentifier(t, "SubstanceInstanceComponent", "identifier", element.getIdentifier(), -1); 20012 } 20013 if (element.hasExpiryElement()) { 20014 composeDateTime(t, "SubstanceInstanceComponent", "expiry", element.getExpiryElement(), -1); 20015 } 20016 if (element.hasQuantity()) { 20017 composeQuantity(t, "SubstanceInstanceComponent", "quantity", element.getQuantity(), -1); 20018 } 20019 } 20020 20021 protected void composeSubstanceIngredientComponent(Complex parent, String parentType, String name, Substance.SubstanceIngredientComponent element, int index) { 20022 if (element == null) 20023 return; 20024 Complex t; 20025 if (Utilities.noString(parentType)) 20026 t = parent; 20027 else { 20028 t = parent.predicate("fhir:"+parentType+'.'+name); 20029 } 20030 composeBackboneElement(t, "ingredient", name, element, index); 20031 if (element.hasQuantity()) { 20032 composeRatio(t, "SubstanceIngredientComponent", "quantity", element.getQuantity(), -1); 20033 } 20034 if (element.hasSubstance()) { 20035 composeType(t, "SubstanceIngredientComponent", "substance", element.getSubstance(), -1); 20036 } 20037 } 20038 20039 protected void composeSubstanceDefinition(Complex parent, String parentType, String name, SubstanceDefinition element, int index) { 20040 if (element == null) 20041 return; 20042 Complex t; 20043 if (Utilities.noString(parentType)) 20044 t = parent; 20045 else { 20046 t = parent.predicate("fhir:"+parentType+'.'+name); 20047 } 20048 composeDomainResource(t, "SubstanceDefinition", name, element, index); 20049 if (element.hasIdentifier()) { 20050 composeIdentifier(t, "SubstanceDefinition", "identifier", element.getIdentifier(), -1); 20051 } 20052 if (element.hasVersionElement()) { 20053 composeString(t, "SubstanceDefinition", "version", element.getVersionElement(), -1); 20054 } 20055 if (element.hasStatus()) { 20056 composeCodeableConcept(t, "SubstanceDefinition", "status", element.getStatus(), -1); 20057 } 20058 if (element.hasCategory()) { 20059 composeCodeableConcept(t, "SubstanceDefinition", "category", element.getCategory(), -1); 20060 } 20061 if (element.hasDomain()) { 20062 composeCodeableConcept(t, "SubstanceDefinition", "domain", element.getDomain(), -1); 20063 } 20064 if (element.hasDescriptionElement()) { 20065 composeMarkdown(t, "SubstanceDefinition", "description", element.getDescriptionElement(), -1); 20066 } 20067 for (int i = 0; i < element.getSource().size(); i++) { 20068 composeReference(t, "SubstanceDefinition", "source", element.getSource().get(i), i); 20069 } 20070 for (int i = 0; i < element.getNote().size(); i++) { 20071 composeAnnotation(t, "SubstanceDefinition", "note", element.getNote().get(i), i); 20072 } 20073 for (int i = 0; i < element.getManufacturer().size(); i++) { 20074 composeReference(t, "SubstanceDefinition", "manufacturer", element.getManufacturer().get(i), i); 20075 } 20076 for (int i = 0; i < element.getSupplier().size(); i++) { 20077 composeReference(t, "SubstanceDefinition", "supplier", element.getSupplier().get(i), i); 20078 } 20079 for (int i = 0; i < element.getMoiety().size(); i++) { 20080 composeSubstanceDefinitionMoietyComponent(t, "SubstanceDefinition", "moiety", element.getMoiety().get(i), i); 20081 } 20082 for (int i = 0; i < element.getProperty().size(); i++) { 20083 composeSubstanceDefinitionPropertyComponent(t, "SubstanceDefinition", "property", element.getProperty().get(i), i); 20084 } 20085 if (element.hasReferenceInformation()) { 20086 composeReference(t, "SubstanceDefinition", "referenceInformation", element.getReferenceInformation(), -1); 20087 } 20088 if (element.hasStructure()) { 20089 composeSubstanceDefinitionStructureComponent(t, "SubstanceDefinition", "structure", element.getStructure(), -1); 20090 } 20091 for (int i = 0; i < element.getCode().size(); i++) { 20092 composeSubstanceDefinitionCodeComponent(t, "SubstanceDefinition", "code", element.getCode().get(i), i); 20093 } 20094 for (int i = 0; i < element.getName().size(); i++) { 20095 composeSubstanceDefinitionNameComponent(t, "SubstanceDefinition", "name", element.getName().get(i), i); 20096 } 20097 for (int i = 0; i < element.getMolecularWeight().size(); i++) { 20098 composeSubstanceDefinitionStructureIsotopeMolecularWeightComponent(t, "SubstanceDefinition", "molecularWeight", element.getMolecularWeight().get(i), i); 20099 } 20100 for (int i = 0; i < element.getRelationship().size(); i++) { 20101 composeSubstanceDefinitionRelationshipComponent(t, "SubstanceDefinition", "relationship", element.getRelationship().get(i), i); 20102 } 20103 if (element.hasNucleicAcid()) { 20104 composeReference(t, "SubstanceDefinition", "nucleicAcid", element.getNucleicAcid(), -1); 20105 } 20106 if (element.hasPolymer()) { 20107 composeReference(t, "SubstanceDefinition", "polymer", element.getPolymer(), -1); 20108 } 20109 if (element.hasProtein()) { 20110 composeReference(t, "SubstanceDefinition", "protein", element.getProtein(), -1); 20111 } 20112 if (element.hasSourceMaterial()) { 20113 composeReference(t, "SubstanceDefinition", "sourceMaterial", element.getSourceMaterial(), -1); 20114 } 20115 } 20116 20117 protected void composeSubstanceDefinitionMoietyComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionMoietyComponent element, int index) { 20118 if (element == null) 20119 return; 20120 Complex t; 20121 if (Utilities.noString(parentType)) 20122 t = parent; 20123 else { 20124 t = parent.predicate("fhir:"+parentType+'.'+name); 20125 } 20126 composeBackboneElement(t, "moiety", name, element, index); 20127 if (element.hasRole()) { 20128 composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "role", element.getRole(), -1); 20129 } 20130 if (element.hasIdentifier()) { 20131 composeIdentifier(t, "SubstanceDefinitionMoietyComponent", "identifier", element.getIdentifier(), -1); 20132 } 20133 if (element.hasNameElement()) { 20134 composeString(t, "SubstanceDefinitionMoietyComponent", "name", element.getNameElement(), -1); 20135 } 20136 if (element.hasStereochemistry()) { 20137 composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "stereochemistry", element.getStereochemistry(), -1); 20138 } 20139 if (element.hasOpticalActivity()) { 20140 composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "opticalActivity", element.getOpticalActivity(), -1); 20141 } 20142 if (element.hasMolecularFormulaElement()) { 20143 composeString(t, "SubstanceDefinitionMoietyComponent", "molecularFormula", element.getMolecularFormulaElement(), -1); 20144 } 20145 if (element.hasAmount()) { 20146 composeType(t, "SubstanceDefinitionMoietyComponent", "amount", element.getAmount(), -1); 20147 } 20148 if (element.hasAmountType()) { 20149 composeCodeableConcept(t, "SubstanceDefinitionMoietyComponent", "amountType", element.getAmountType(), -1); 20150 } 20151 } 20152 20153 protected void composeSubstanceDefinitionPropertyComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionPropertyComponent element, int index) { 20154 if (element == null) 20155 return; 20156 Complex t; 20157 if (Utilities.noString(parentType)) 20158 t = parent; 20159 else { 20160 t = parent.predicate("fhir:"+parentType+'.'+name); 20161 } 20162 composeBackboneElement(t, "property", name, element, index); 20163 if (element.hasCategory()) { 20164 composeCodeableConcept(t, "SubstanceDefinitionPropertyComponent", "category", element.getCategory(), -1); 20165 } 20166 if (element.hasCode()) { 20167 composeCodeableConcept(t, "SubstanceDefinitionPropertyComponent", "code", element.getCode(), -1); 20168 } 20169 if (element.hasParametersElement()) { 20170 composeString(t, "SubstanceDefinitionPropertyComponent", "parameters", element.getParametersElement(), -1); 20171 } 20172 if (element.hasDefiningSubstance()) { 20173 composeType(t, "SubstanceDefinitionPropertyComponent", "definingSubstance", element.getDefiningSubstance(), -1); 20174 } 20175 if (element.hasAmount()) { 20176 composeType(t, "SubstanceDefinitionPropertyComponent", "amount", element.getAmount(), -1); 20177 } 20178 if (element.hasReferenceRange()) { 20179 composeRange(t, "SubstanceDefinitionPropertyComponent", "referenceRange", element.getReferenceRange(), -1); 20180 } 20181 for (int i = 0; i < element.getSource().size(); i++) { 20182 composeReference(t, "SubstanceDefinitionPropertyComponent", "source", element.getSource().get(i), i); 20183 } 20184 } 20185 20186 protected void composeSubstanceDefinitionStructureComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionStructureComponent element, int index) { 20187 if (element == null) 20188 return; 20189 Complex t; 20190 if (Utilities.noString(parentType)) 20191 t = parent; 20192 else { 20193 t = parent.predicate("fhir:"+parentType+'.'+name); 20194 } 20195 composeBackboneElement(t, "structure", name, element, index); 20196 if (element.hasStereochemistry()) { 20197 composeCodeableConcept(t, "SubstanceDefinitionStructureComponent", "stereochemistry", element.getStereochemistry(), -1); 20198 } 20199 if (element.hasOpticalActivity()) { 20200 composeCodeableConcept(t, "SubstanceDefinitionStructureComponent", "opticalActivity", element.getOpticalActivity(), -1); 20201 } 20202 if (element.hasMolecularFormulaElement()) { 20203 composeString(t, "SubstanceDefinitionStructureComponent", "molecularFormula", element.getMolecularFormulaElement(), -1); 20204 } 20205 if (element.hasMolecularFormulaByMoietyElement()) { 20206 composeString(t, "SubstanceDefinitionStructureComponent", "molecularFormulaByMoiety", element.getMolecularFormulaByMoietyElement(), -1); 20207 } 20208 for (int i = 0; i < element.getIsotope().size(); i++) { 20209 composeSubstanceDefinitionStructureIsotopeComponent(t, "SubstanceDefinitionStructureComponent", "isotope", element.getIsotope().get(i), i); 20210 } 20211 if (element.hasMolecularWeight()) { 20212 composeSubstanceDefinitionStructureIsotopeMolecularWeightComponent(t, "SubstanceDefinitionStructureComponent", "molecularWeight", element.getMolecularWeight(), -1); 20213 } 20214 for (int i = 0; i < element.getSourceCoding().size(); i++) { 20215 composeCoding(t, "SubstanceDefinitionStructureComponent", "sourceCoding", element.getSourceCoding().get(i), i); 20216 } 20217 for (int i = 0; i < element.getSourceDocument().size(); i++) { 20218 composeReference(t, "SubstanceDefinitionStructureComponent", "sourceDocument", element.getSourceDocument().get(i), i); 20219 } 20220 for (int i = 0; i < element.getRepresentation().size(); i++) { 20221 composeSubstanceDefinitionStructureRepresentationComponent(t, "SubstanceDefinitionStructureComponent", "representation", element.getRepresentation().get(i), i); 20222 } 20223 } 20224 20225 protected void composeSubstanceDefinitionStructureIsotopeComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionStructureIsotopeComponent element, int index) { 20226 if (element == null) 20227 return; 20228 Complex t; 20229 if (Utilities.noString(parentType)) 20230 t = parent; 20231 else { 20232 t = parent.predicate("fhir:"+parentType+'.'+name); 20233 } 20234 composeBackboneElement(t, "isotope", name, element, index); 20235 if (element.hasIdentifier()) { 20236 composeIdentifier(t, "SubstanceDefinitionStructureIsotopeComponent", "identifier", element.getIdentifier(), -1); 20237 } 20238 if (element.hasName()) { 20239 composeCodeableConcept(t, "SubstanceDefinitionStructureIsotopeComponent", "name", element.getName(), -1); 20240 } 20241 if (element.hasSubstitution()) { 20242 composeCodeableConcept(t, "SubstanceDefinitionStructureIsotopeComponent", "substitution", element.getSubstitution(), -1); 20243 } 20244 if (element.hasHalfLife()) { 20245 composeQuantity(t, "SubstanceDefinitionStructureIsotopeComponent", "halfLife", element.getHalfLife(), -1); 20246 } 20247 if (element.hasMolecularWeight()) { 20248 composeSubstanceDefinitionStructureIsotopeMolecularWeightComponent(t, "SubstanceDefinitionStructureIsotopeComponent", "molecularWeight", element.getMolecularWeight(), -1); 20249 } 20250 } 20251 20252 protected void composeSubstanceDefinitionStructureIsotopeMolecularWeightComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionStructureIsotopeMolecularWeightComponent element, int index) { 20253 if (element == null) 20254 return; 20255 Complex t; 20256 if (Utilities.noString(parentType)) 20257 t = parent; 20258 else { 20259 t = parent.predicate("fhir:"+parentType+'.'+name); 20260 } 20261 composeBackboneElement(t, "molecularWeight", name, element, index); 20262 if (element.hasMethod()) { 20263 composeCodeableConcept(t, "SubstanceDefinitionStructureIsotopeMolecularWeightComponent", "method", element.getMethod(), -1); 20264 } 20265 if (element.hasType()) { 20266 composeCodeableConcept(t, "SubstanceDefinitionStructureIsotopeMolecularWeightComponent", "type", element.getType(), -1); 20267 } 20268 if (element.hasAmount()) { 20269 composeQuantity(t, "SubstanceDefinitionStructureIsotopeMolecularWeightComponent", "amount", element.getAmount(), -1); 20270 } 20271 } 20272 20273 protected void composeSubstanceDefinitionStructureRepresentationComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionStructureRepresentationComponent element, int index) { 20274 if (element == null) 20275 return; 20276 Complex t; 20277 if (Utilities.noString(parentType)) 20278 t = parent; 20279 else { 20280 t = parent.predicate("fhir:"+parentType+'.'+name); 20281 } 20282 composeBackboneElement(t, "representation", name, element, index); 20283 if (element.hasType()) { 20284 composeCodeableConcept(t, "SubstanceDefinitionStructureRepresentationComponent", "type", element.getType(), -1); 20285 } 20286 if (element.hasRepresentationElement()) { 20287 composeString(t, "SubstanceDefinitionStructureRepresentationComponent", "representation", element.getRepresentationElement(), -1); 20288 } 20289 if (element.hasAttachment()) { 20290 composeAttachment(t, "SubstanceDefinitionStructureRepresentationComponent", "attachment", element.getAttachment(), -1); 20291 } 20292 } 20293 20294 protected void composeSubstanceDefinitionCodeComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionCodeComponent element, int index) { 20295 if (element == null) 20296 return; 20297 Complex t; 20298 if (Utilities.noString(parentType)) 20299 t = parent; 20300 else { 20301 t = parent.predicate("fhir:"+parentType+'.'+name); 20302 } 20303 composeBackboneElement(t, "code", name, element, index); 20304 if (element.hasCode()) { 20305 composeCodeableConcept(t, "SubstanceDefinitionCodeComponent", "code", element.getCode(), -1); 20306 } 20307 if (element.hasStatus()) { 20308 composeCodeableConcept(t, "SubstanceDefinitionCodeComponent", "status", element.getStatus(), -1); 20309 } 20310 if (element.hasStatusDateElement()) { 20311 composeDateTime(t, "SubstanceDefinitionCodeComponent", "statusDate", element.getStatusDateElement(), -1); 20312 } 20313 for (int i = 0; i < element.getNote().size(); i++) { 20314 composeAnnotation(t, "SubstanceDefinitionCodeComponent", "note", element.getNote().get(i), i); 20315 } 20316 for (int i = 0; i < element.getSource().size(); i++) { 20317 composeReference(t, "SubstanceDefinitionCodeComponent", "source", element.getSource().get(i), i); 20318 } 20319 } 20320 20321 protected void composeSubstanceDefinitionNameComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionNameComponent element, int index) { 20322 if (element == null) 20323 return; 20324 Complex t; 20325 if (Utilities.noString(parentType)) 20326 t = parent; 20327 else { 20328 t = parent.predicate("fhir:"+parentType+'.'+name); 20329 } 20330 composeBackboneElement(t, "name", name, element, index); 20331 if (element.hasNameElement()) { 20332 composeString(t, "SubstanceDefinitionNameComponent", "name", element.getNameElement(), -1); 20333 } 20334 if (element.hasType()) { 20335 composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "type", element.getType(), -1); 20336 } 20337 if (element.hasStatus()) { 20338 composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "status", element.getStatus(), -1); 20339 } 20340 if (element.hasPreferredElement()) { 20341 composeBoolean(t, "SubstanceDefinitionNameComponent", "preferred", element.getPreferredElement(), -1); 20342 } 20343 for (int i = 0; i < element.getLanguage().size(); i++) { 20344 composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "language", element.getLanguage().get(i), i); 20345 } 20346 for (int i = 0; i < element.getDomain().size(); i++) { 20347 composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "domain", element.getDomain().get(i), i); 20348 } 20349 for (int i = 0; i < element.getJurisdiction().size(); i++) { 20350 composeCodeableConcept(t, "SubstanceDefinitionNameComponent", "jurisdiction", element.getJurisdiction().get(i), i); 20351 } 20352 for (int i = 0; i < element.getSynonym().size(); i++) { 20353 composeSubstanceDefinitionNameComponent(t, "SubstanceDefinitionNameComponent", "synonym", element.getSynonym().get(i), i); 20354 } 20355 for (int i = 0; i < element.getTranslation().size(); i++) { 20356 composeSubstanceDefinitionNameComponent(t, "SubstanceDefinitionNameComponent", "translation", element.getTranslation().get(i), i); 20357 } 20358 for (int i = 0; i < element.getOfficial().size(); i++) { 20359 composeSubstanceDefinitionNameOfficialComponent(t, "SubstanceDefinitionNameComponent", "official", element.getOfficial().get(i), i); 20360 } 20361 for (int i = 0; i < element.getSource().size(); i++) { 20362 composeReference(t, "SubstanceDefinitionNameComponent", "source", element.getSource().get(i), i); 20363 } 20364 } 20365 20366 protected void composeSubstanceDefinitionNameOfficialComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionNameOfficialComponent element, int index) { 20367 if (element == null) 20368 return; 20369 Complex t; 20370 if (Utilities.noString(parentType)) 20371 t = parent; 20372 else { 20373 t = parent.predicate("fhir:"+parentType+'.'+name); 20374 } 20375 composeBackboneElement(t, "official", name, element, index); 20376 if (element.hasAuthority()) { 20377 composeCodeableConcept(t, "SubstanceDefinitionNameOfficialComponent", "authority", element.getAuthority(), -1); 20378 } 20379 if (element.hasStatus()) { 20380 composeCodeableConcept(t, "SubstanceDefinitionNameOfficialComponent", "status", element.getStatus(), -1); 20381 } 20382 if (element.hasDateElement()) { 20383 composeDateTime(t, "SubstanceDefinitionNameOfficialComponent", "date", element.getDateElement(), -1); 20384 } 20385 } 20386 20387 protected void composeSubstanceDefinitionRelationshipComponent(Complex parent, String parentType, String name, SubstanceDefinition.SubstanceDefinitionRelationshipComponent element, int index) { 20388 if (element == null) 20389 return; 20390 Complex t; 20391 if (Utilities.noString(parentType)) 20392 t = parent; 20393 else { 20394 t = parent.predicate("fhir:"+parentType+'.'+name); 20395 } 20396 composeBackboneElement(t, "relationship", name, element, index); 20397 if (element.hasSubstanceDefinition()) { 20398 composeType(t, "SubstanceDefinitionRelationshipComponent", "substanceDefinition", element.getSubstanceDefinition(), -1); 20399 } 20400 if (element.hasType()) { 20401 composeCodeableConcept(t, "SubstanceDefinitionRelationshipComponent", "type", element.getType(), -1); 20402 } 20403 if (element.hasIsDefiningElement()) { 20404 composeBoolean(t, "SubstanceDefinitionRelationshipComponent", "isDefining", element.getIsDefiningElement(), -1); 20405 } 20406 if (element.hasAmount()) { 20407 composeType(t, "SubstanceDefinitionRelationshipComponent", "amount", element.getAmount(), -1); 20408 } 20409 if (element.hasAmountRatioHighLimit()) { 20410 composeRatio(t, "SubstanceDefinitionRelationshipComponent", "amountRatioHighLimit", element.getAmountRatioHighLimit(), -1); 20411 } 20412 if (element.hasAmountType()) { 20413 composeCodeableConcept(t, "SubstanceDefinitionRelationshipComponent", "amountType", element.getAmountType(), -1); 20414 } 20415 for (int i = 0; i < element.getSource().size(); i++) { 20416 composeReference(t, "SubstanceDefinitionRelationshipComponent", "source", element.getSource().get(i), i); 20417 } 20418 } 20419 20420 protected void composeSubstanceNucleicAcid(Complex parent, String parentType, String name, SubstanceNucleicAcid element, int index) { 20421 if (element == null) 20422 return; 20423 Complex t; 20424 if (Utilities.noString(parentType)) 20425 t = parent; 20426 else { 20427 t = parent.predicate("fhir:"+parentType+'.'+name); 20428 } 20429 composeDomainResource(t, "SubstanceNucleicAcid", name, element, index); 20430 if (element.hasSequenceType()) { 20431 composeCodeableConcept(t, "SubstanceNucleicAcid", "sequenceType", element.getSequenceType(), -1); 20432 } 20433 if (element.hasNumberOfSubunitsElement()) { 20434 composeInteger(t, "SubstanceNucleicAcid", "numberOfSubunits", element.getNumberOfSubunitsElement(), -1); 20435 } 20436 if (element.hasAreaOfHybridisationElement()) { 20437 composeString(t, "SubstanceNucleicAcid", "areaOfHybridisation", element.getAreaOfHybridisationElement(), -1); 20438 } 20439 if (element.hasOligoNucleotideType()) { 20440 composeCodeableConcept(t, "SubstanceNucleicAcid", "oligoNucleotideType", element.getOligoNucleotideType(), -1); 20441 } 20442 for (int i = 0; i < element.getSubunit().size(); i++) { 20443 composeSubstanceNucleicAcidSubunitComponent(t, "SubstanceNucleicAcid", "subunit", element.getSubunit().get(i), i); 20444 } 20445 } 20446 20447 protected void composeSubstanceNucleicAcidSubunitComponent(Complex parent, String parentType, String name, SubstanceNucleicAcid.SubstanceNucleicAcidSubunitComponent element, int index) { 20448 if (element == null) 20449 return; 20450 Complex t; 20451 if (Utilities.noString(parentType)) 20452 t = parent; 20453 else { 20454 t = parent.predicate("fhir:"+parentType+'.'+name); 20455 } 20456 composeBackboneElement(t, "subunit", name, element, index); 20457 if (element.hasSubunitElement()) { 20458 composeInteger(t, "SubstanceNucleicAcidSubunitComponent", "subunit", element.getSubunitElement(), -1); 20459 } 20460 if (element.hasSequenceElement()) { 20461 composeString(t, "SubstanceNucleicAcidSubunitComponent", "sequence", element.getSequenceElement(), -1); 20462 } 20463 if (element.hasLengthElement()) { 20464 composeInteger(t, "SubstanceNucleicAcidSubunitComponent", "length", element.getLengthElement(), -1); 20465 } 20466 if (element.hasSequenceAttachment()) { 20467 composeAttachment(t, "SubstanceNucleicAcidSubunitComponent", "sequenceAttachment", element.getSequenceAttachment(), -1); 20468 } 20469 if (element.hasFivePrime()) { 20470 composeCodeableConcept(t, "SubstanceNucleicAcidSubunitComponent", "fivePrime", element.getFivePrime(), -1); 20471 } 20472 if (element.hasThreePrime()) { 20473 composeCodeableConcept(t, "SubstanceNucleicAcidSubunitComponent", "threePrime", element.getThreePrime(), -1); 20474 } 20475 for (int i = 0; i < element.getLinkage().size(); i++) { 20476 composeSubstanceNucleicAcidSubunitLinkageComponent(t, "SubstanceNucleicAcidSubunitComponent", "linkage", element.getLinkage().get(i), i); 20477 } 20478 for (int i = 0; i < element.getSugar().size(); i++) { 20479 composeSubstanceNucleicAcidSubunitSugarComponent(t, "SubstanceNucleicAcidSubunitComponent", "sugar", element.getSugar().get(i), i); 20480 } 20481 } 20482 20483 protected void composeSubstanceNucleicAcidSubunitLinkageComponent(Complex parent, String parentType, String name, SubstanceNucleicAcid.SubstanceNucleicAcidSubunitLinkageComponent element, int index) { 20484 if (element == null) 20485 return; 20486 Complex t; 20487 if (Utilities.noString(parentType)) 20488 t = parent; 20489 else { 20490 t = parent.predicate("fhir:"+parentType+'.'+name); 20491 } 20492 composeBackboneElement(t, "linkage", name, element, index); 20493 if (element.hasConnectivityElement()) { 20494 composeString(t, "SubstanceNucleicAcidSubunitLinkageComponent", "connectivity", element.getConnectivityElement(), -1); 20495 } 20496 if (element.hasIdentifier()) { 20497 composeIdentifier(t, "SubstanceNucleicAcidSubunitLinkageComponent", "identifier", element.getIdentifier(), -1); 20498 } 20499 if (element.hasNameElement()) { 20500 composeString(t, "SubstanceNucleicAcidSubunitLinkageComponent", "name", element.getNameElement(), -1); 20501 } 20502 if (element.hasResidueSiteElement()) { 20503 composeString(t, "SubstanceNucleicAcidSubunitLinkageComponent", "residueSite", element.getResidueSiteElement(), -1); 20504 } 20505 } 20506 20507 protected void composeSubstanceNucleicAcidSubunitSugarComponent(Complex parent, String parentType, String name, SubstanceNucleicAcid.SubstanceNucleicAcidSubunitSugarComponent element, int index) { 20508 if (element == null) 20509 return; 20510 Complex t; 20511 if (Utilities.noString(parentType)) 20512 t = parent; 20513 else { 20514 t = parent.predicate("fhir:"+parentType+'.'+name); 20515 } 20516 composeBackboneElement(t, "sugar", name, element, index); 20517 if (element.hasIdentifier()) { 20518 composeIdentifier(t, "SubstanceNucleicAcidSubunitSugarComponent", "identifier", element.getIdentifier(), -1); 20519 } 20520 if (element.hasNameElement()) { 20521 composeString(t, "SubstanceNucleicAcidSubunitSugarComponent", "name", element.getNameElement(), -1); 20522 } 20523 if (element.hasResidueSiteElement()) { 20524 composeString(t, "SubstanceNucleicAcidSubunitSugarComponent", "residueSite", element.getResidueSiteElement(), -1); 20525 } 20526 } 20527 20528 protected void composeSubstancePolymer(Complex parent, String parentType, String name, SubstancePolymer element, int index) { 20529 if (element == null) 20530 return; 20531 Complex t; 20532 if (Utilities.noString(parentType)) 20533 t = parent; 20534 else { 20535 t = parent.predicate("fhir:"+parentType+'.'+name); 20536 } 20537 composeDomainResource(t, "SubstancePolymer", name, element, index); 20538 if (element.hasClass_()) { 20539 composeCodeableConcept(t, "SubstancePolymer", "class", element.getClass_(), -1); 20540 } 20541 if (element.hasGeometry()) { 20542 composeCodeableConcept(t, "SubstancePolymer", "geometry", element.getGeometry(), -1); 20543 } 20544 for (int i = 0; i < element.getCopolymerConnectivity().size(); i++) { 20545 composeCodeableConcept(t, "SubstancePolymer", "copolymerConnectivity", element.getCopolymerConnectivity().get(i), i); 20546 } 20547 for (int i = 0; i < element.getModification().size(); i++) { 20548 composeString(t, "SubstancePolymer", "modification", element.getModification().get(i), i); 20549 } 20550 for (int i = 0; i < element.getMonomerSet().size(); i++) { 20551 composeSubstancePolymerMonomerSetComponent(t, "SubstancePolymer", "monomerSet", element.getMonomerSet().get(i), i); 20552 } 20553 for (int i = 0; i < element.getRepeat().size(); i++) { 20554 composeSubstancePolymerRepeatComponent(t, "SubstancePolymer", "repeat", element.getRepeat().get(i), i); 20555 } 20556 } 20557 20558 protected void composeSubstancePolymerMonomerSetComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerMonomerSetComponent element, int index) { 20559 if (element == null) 20560 return; 20561 Complex t; 20562 if (Utilities.noString(parentType)) 20563 t = parent; 20564 else { 20565 t = parent.predicate("fhir:"+parentType+'.'+name); 20566 } 20567 composeBackboneElement(t, "monomerSet", name, element, index); 20568 if (element.hasRatioType()) { 20569 composeCodeableConcept(t, "SubstancePolymerMonomerSetComponent", "ratioType", element.getRatioType(), -1); 20570 } 20571 for (int i = 0; i < element.getStartingMaterial().size(); i++) { 20572 composeSubstancePolymerMonomerSetStartingMaterialComponent(t, "SubstancePolymerMonomerSetComponent", "startingMaterial", element.getStartingMaterial().get(i), i); 20573 } 20574 } 20575 20576 protected void composeSubstancePolymerMonomerSetStartingMaterialComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerMonomerSetStartingMaterialComponent element, int index) { 20577 if (element == null) 20578 return; 20579 Complex t; 20580 if (Utilities.noString(parentType)) 20581 t = parent; 20582 else { 20583 t = parent.predicate("fhir:"+parentType+'.'+name); 20584 } 20585 composeBackboneElement(t, "startingMaterial", name, element, index); 20586 if (element.hasMaterial()) { 20587 composeCodeableConcept(t, "SubstancePolymerMonomerSetStartingMaterialComponent", "material", element.getMaterial(), -1); 20588 } 20589 if (element.hasType()) { 20590 composeCodeableConcept(t, "SubstancePolymerMonomerSetStartingMaterialComponent", "type", element.getType(), -1); 20591 } 20592 if (element.hasIsDefiningElement()) { 20593 composeBoolean(t, "SubstancePolymerMonomerSetStartingMaterialComponent", "isDefining", element.getIsDefiningElement(), -1); 20594 } 20595 if (element.hasAmount()) { 20596 composeSubstanceAmount(t, "SubstancePolymerMonomerSetStartingMaterialComponent", "amount", element.getAmount(), -1); 20597 } 20598 } 20599 20600 protected void composeSubstancePolymerRepeatComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatComponent element, int index) { 20601 if (element == null) 20602 return; 20603 Complex t; 20604 if (Utilities.noString(parentType)) 20605 t = parent; 20606 else { 20607 t = parent.predicate("fhir:"+parentType+'.'+name); 20608 } 20609 composeBackboneElement(t, "repeat", name, element, index); 20610 if (element.hasNumberOfUnitsElement()) { 20611 composeInteger(t, "SubstancePolymerRepeatComponent", "numberOfUnits", element.getNumberOfUnitsElement(), -1); 20612 } 20613 if (element.hasAverageMolecularFormulaElement()) { 20614 composeString(t, "SubstancePolymerRepeatComponent", "averageMolecularFormula", element.getAverageMolecularFormulaElement(), -1); 20615 } 20616 if (element.hasRepeatUnitAmountType()) { 20617 composeCodeableConcept(t, "SubstancePolymerRepeatComponent", "repeatUnitAmountType", element.getRepeatUnitAmountType(), -1); 20618 } 20619 for (int i = 0; i < element.getRepeatUnit().size(); i++) { 20620 composeSubstancePolymerRepeatRepeatUnitComponent(t, "SubstancePolymerRepeatComponent", "repeatUnit", element.getRepeatUnit().get(i), i); 20621 } 20622 } 20623 20624 protected void composeSubstancePolymerRepeatRepeatUnitComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatRepeatUnitComponent element, int index) { 20625 if (element == null) 20626 return; 20627 Complex t; 20628 if (Utilities.noString(parentType)) 20629 t = parent; 20630 else { 20631 t = parent.predicate("fhir:"+parentType+'.'+name); 20632 } 20633 composeBackboneElement(t, "repeatUnit", name, element, index); 20634 if (element.hasOrientationOfPolymerisation()) { 20635 composeCodeableConcept(t, "SubstancePolymerRepeatRepeatUnitComponent", "orientationOfPolymerisation", element.getOrientationOfPolymerisation(), -1); 20636 } 20637 if (element.hasRepeatUnitElement()) { 20638 composeString(t, "SubstancePolymerRepeatRepeatUnitComponent", "repeatUnit", element.getRepeatUnitElement(), -1); 20639 } 20640 if (element.hasAmount()) { 20641 composeSubstanceAmount(t, "SubstancePolymerRepeatRepeatUnitComponent", "amount", element.getAmount(), -1); 20642 } 20643 for (int i = 0; i < element.getDegreeOfPolymerisation().size(); i++) { 20644 composeSubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent(t, "SubstancePolymerRepeatRepeatUnitComponent", "degreeOfPolymerisation", element.getDegreeOfPolymerisation().get(i), i); 20645 } 20646 for (int i = 0; i < element.getStructuralRepresentation().size(); i++) { 20647 composeSubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent(t, "SubstancePolymerRepeatRepeatUnitComponent", "structuralRepresentation", element.getStructuralRepresentation().get(i), i); 20648 } 20649 } 20650 20651 protected void composeSubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent element, int index) { 20652 if (element == null) 20653 return; 20654 Complex t; 20655 if (Utilities.noString(parentType)) 20656 t = parent; 20657 else { 20658 t = parent.predicate("fhir:"+parentType+'.'+name); 20659 } 20660 composeBackboneElement(t, "degreeOfPolymerisation", name, element, index); 20661 if (element.hasDegree()) { 20662 composeCodeableConcept(t, "SubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent", "degree", element.getDegree(), -1); 20663 } 20664 if (element.hasAmount()) { 20665 composeSubstanceAmount(t, "SubstancePolymerRepeatRepeatUnitDegreeOfPolymerisationComponent", "amount", element.getAmount(), -1); 20666 } 20667 } 20668 20669 protected void composeSubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent(Complex parent, String parentType, String name, SubstancePolymer.SubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent element, int index) { 20670 if (element == null) 20671 return; 20672 Complex t; 20673 if (Utilities.noString(parentType)) 20674 t = parent; 20675 else { 20676 t = parent.predicate("fhir:"+parentType+'.'+name); 20677 } 20678 composeBackboneElement(t, "structuralRepresentation", name, element, index); 20679 if (element.hasType()) { 20680 composeCodeableConcept(t, "SubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent", "type", element.getType(), -1); 20681 } 20682 if (element.hasRepresentationElement()) { 20683 composeString(t, "SubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent", "representation", element.getRepresentationElement(), -1); 20684 } 20685 if (element.hasAttachment()) { 20686 composeAttachment(t, "SubstancePolymerRepeatRepeatUnitStructuralRepresentationComponent", "attachment", element.getAttachment(), -1); 20687 } 20688 } 20689 20690 protected void composeSubstanceProtein(Complex parent, String parentType, String name, SubstanceProtein element, int index) { 20691 if (element == null) 20692 return; 20693 Complex t; 20694 if (Utilities.noString(parentType)) 20695 t = parent; 20696 else { 20697 t = parent.predicate("fhir:"+parentType+'.'+name); 20698 } 20699 composeDomainResource(t, "SubstanceProtein", name, element, index); 20700 if (element.hasSequenceType()) { 20701 composeCodeableConcept(t, "SubstanceProtein", "sequenceType", element.getSequenceType(), -1); 20702 } 20703 if (element.hasNumberOfSubunitsElement()) { 20704 composeInteger(t, "SubstanceProtein", "numberOfSubunits", element.getNumberOfSubunitsElement(), -1); 20705 } 20706 for (int i = 0; i < element.getDisulfideLinkage().size(); i++) { 20707 composeString(t, "SubstanceProtein", "disulfideLinkage", element.getDisulfideLinkage().get(i), i); 20708 } 20709 for (int i = 0; i < element.getSubunit().size(); i++) { 20710 composeSubstanceProteinSubunitComponent(t, "SubstanceProtein", "subunit", element.getSubunit().get(i), i); 20711 } 20712 } 20713 20714 protected void composeSubstanceProteinSubunitComponent(Complex parent, String parentType, String name, SubstanceProtein.SubstanceProteinSubunitComponent element, int index) { 20715 if (element == null) 20716 return; 20717 Complex t; 20718 if (Utilities.noString(parentType)) 20719 t = parent; 20720 else { 20721 t = parent.predicate("fhir:"+parentType+'.'+name); 20722 } 20723 composeBackboneElement(t, "subunit", name, element, index); 20724 if (element.hasSubunitElement()) { 20725 composeInteger(t, "SubstanceProteinSubunitComponent", "subunit", element.getSubunitElement(), -1); 20726 } 20727 if (element.hasSequenceElement()) { 20728 composeString(t, "SubstanceProteinSubunitComponent", "sequence", element.getSequenceElement(), -1); 20729 } 20730 if (element.hasLengthElement()) { 20731 composeInteger(t, "SubstanceProteinSubunitComponent", "length", element.getLengthElement(), -1); 20732 } 20733 if (element.hasSequenceAttachment()) { 20734 composeAttachment(t, "SubstanceProteinSubunitComponent", "sequenceAttachment", element.getSequenceAttachment(), -1); 20735 } 20736 if (element.hasNTerminalModificationId()) { 20737 composeIdentifier(t, "SubstanceProteinSubunitComponent", "nTerminalModificationId", element.getNTerminalModificationId(), -1); 20738 } 20739 if (element.hasNTerminalModificationElement()) { 20740 composeString(t, "SubstanceProteinSubunitComponent", "nTerminalModification", element.getNTerminalModificationElement(), -1); 20741 } 20742 if (element.hasCTerminalModificationId()) { 20743 composeIdentifier(t, "SubstanceProteinSubunitComponent", "cTerminalModificationId", element.getCTerminalModificationId(), -1); 20744 } 20745 if (element.hasCTerminalModificationElement()) { 20746 composeString(t, "SubstanceProteinSubunitComponent", "cTerminalModification", element.getCTerminalModificationElement(), -1); 20747 } 20748 } 20749 20750 protected void composeSubstanceReferenceInformation(Complex parent, String parentType, String name, SubstanceReferenceInformation element, int index) { 20751 if (element == null) 20752 return; 20753 Complex t; 20754 if (Utilities.noString(parentType)) 20755 t = parent; 20756 else { 20757 t = parent.predicate("fhir:"+parentType+'.'+name); 20758 } 20759 composeDomainResource(t, "SubstanceReferenceInformation", name, element, index); 20760 if (element.hasCommentElement()) { 20761 composeString(t, "SubstanceReferenceInformation", "comment", element.getCommentElement(), -1); 20762 } 20763 for (int i = 0; i < element.getGene().size(); i++) { 20764 composeSubstanceReferenceInformationGeneComponent(t, "SubstanceReferenceInformation", "gene", element.getGene().get(i), i); 20765 } 20766 for (int i = 0; i < element.getGeneElement().size(); i++) { 20767 composeSubstanceReferenceInformationGeneElementComponent(t, "SubstanceReferenceInformation", "geneElement", element.getGeneElement().get(i), i); 20768 } 20769 for (int i = 0; i < element.getClassification().size(); i++) { 20770 composeSubstanceReferenceInformationClassificationComponent(t, "SubstanceReferenceInformation", "classification", element.getClassification().get(i), i); 20771 } 20772 for (int i = 0; i < element.getTarget().size(); i++) { 20773 composeSubstanceReferenceInformationTargetComponent(t, "SubstanceReferenceInformation", "target", element.getTarget().get(i), i); 20774 } 20775 } 20776 20777 protected void composeSubstanceReferenceInformationGeneComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationGeneComponent element, int index) { 20778 if (element == null) 20779 return; 20780 Complex t; 20781 if (Utilities.noString(parentType)) 20782 t = parent; 20783 else { 20784 t = parent.predicate("fhir:"+parentType+'.'+name); 20785 } 20786 composeBackboneElement(t, "gene", name, element, index); 20787 if (element.hasGeneSequenceOrigin()) { 20788 composeCodeableConcept(t, "SubstanceReferenceInformationGeneComponent", "geneSequenceOrigin", element.getGeneSequenceOrigin(), -1); 20789 } 20790 if (element.hasGene()) { 20791 composeCodeableConcept(t, "SubstanceReferenceInformationGeneComponent", "gene", element.getGene(), -1); 20792 } 20793 for (int i = 0; i < element.getSource().size(); i++) { 20794 composeReference(t, "SubstanceReferenceInformationGeneComponent", "source", element.getSource().get(i), i); 20795 } 20796 } 20797 20798 protected void composeSubstanceReferenceInformationGeneElementComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationGeneElementComponent element, int index) { 20799 if (element == null) 20800 return; 20801 Complex t; 20802 if (Utilities.noString(parentType)) 20803 t = parent; 20804 else { 20805 t = parent.predicate("fhir:"+parentType+'.'+name); 20806 } 20807 composeBackboneElement(t, "geneElement", name, element, index); 20808 if (element.hasType()) { 20809 composeCodeableConcept(t, "SubstanceReferenceInformationGeneElementComponent", "type", element.getType(), -1); 20810 } 20811 if (element.hasElement()) { 20812 composeIdentifier(t, "SubstanceReferenceInformationGeneElementComponent", "element", element.getElement(), -1); 20813 } 20814 for (int i = 0; i < element.getSource().size(); i++) { 20815 composeReference(t, "SubstanceReferenceInformationGeneElementComponent", "source", element.getSource().get(i), i); 20816 } 20817 } 20818 20819 protected void composeSubstanceReferenceInformationClassificationComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationClassificationComponent element, int index) { 20820 if (element == null) 20821 return; 20822 Complex t; 20823 if (Utilities.noString(parentType)) 20824 t = parent; 20825 else { 20826 t = parent.predicate("fhir:"+parentType+'.'+name); 20827 } 20828 composeBackboneElement(t, "classification", name, element, index); 20829 if (element.hasDomain()) { 20830 composeCodeableConcept(t, "SubstanceReferenceInformationClassificationComponent", "domain", element.getDomain(), -1); 20831 } 20832 if (element.hasClassification()) { 20833 composeCodeableConcept(t, "SubstanceReferenceInformationClassificationComponent", "classification", element.getClassification(), -1); 20834 } 20835 for (int i = 0; i < element.getSubtype().size(); i++) { 20836 composeCodeableConcept(t, "SubstanceReferenceInformationClassificationComponent", "subtype", element.getSubtype().get(i), i); 20837 } 20838 for (int i = 0; i < element.getSource().size(); i++) { 20839 composeReference(t, "SubstanceReferenceInformationClassificationComponent", "source", element.getSource().get(i), i); 20840 } 20841 } 20842 20843 protected void composeSubstanceReferenceInformationTargetComponent(Complex parent, String parentType, String name, SubstanceReferenceInformation.SubstanceReferenceInformationTargetComponent element, int index) { 20844 if (element == null) 20845 return; 20846 Complex t; 20847 if (Utilities.noString(parentType)) 20848 t = parent; 20849 else { 20850 t = parent.predicate("fhir:"+parentType+'.'+name); 20851 } 20852 composeBackboneElement(t, "target", name, element, index); 20853 if (element.hasTarget()) { 20854 composeIdentifier(t, "SubstanceReferenceInformationTargetComponent", "target", element.getTarget(), -1); 20855 } 20856 if (element.hasType()) { 20857 composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "type", element.getType(), -1); 20858 } 20859 if (element.hasInteraction()) { 20860 composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "interaction", element.getInteraction(), -1); 20861 } 20862 if (element.hasOrganism()) { 20863 composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "organism", element.getOrganism(), -1); 20864 } 20865 if (element.hasOrganismType()) { 20866 composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "organismType", element.getOrganismType(), -1); 20867 } 20868 if (element.hasAmount()) { 20869 composeType(t, "SubstanceReferenceInformationTargetComponent", "amount", element.getAmount(), -1); 20870 } 20871 if (element.hasAmountType()) { 20872 composeCodeableConcept(t, "SubstanceReferenceInformationTargetComponent", "amountType", element.getAmountType(), -1); 20873 } 20874 for (int i = 0; i < element.getSource().size(); i++) { 20875 composeReference(t, "SubstanceReferenceInformationTargetComponent", "source", element.getSource().get(i), i); 20876 } 20877 } 20878 20879 protected void composeSubstanceSourceMaterial(Complex parent, String parentType, String name, SubstanceSourceMaterial element, int index) { 20880 if (element == null) 20881 return; 20882 Complex t; 20883 if (Utilities.noString(parentType)) 20884 t = parent; 20885 else { 20886 t = parent.predicate("fhir:"+parentType+'.'+name); 20887 } 20888 composeDomainResource(t, "SubstanceSourceMaterial", name, element, index); 20889 if (element.hasSourceMaterialClass()) { 20890 composeCodeableConcept(t, "SubstanceSourceMaterial", "sourceMaterialClass", element.getSourceMaterialClass(), -1); 20891 } 20892 if (element.hasSourceMaterialType()) { 20893 composeCodeableConcept(t, "SubstanceSourceMaterial", "sourceMaterialType", element.getSourceMaterialType(), -1); 20894 } 20895 if (element.hasSourceMaterialState()) { 20896 composeCodeableConcept(t, "SubstanceSourceMaterial", "sourceMaterialState", element.getSourceMaterialState(), -1); 20897 } 20898 if (element.hasOrganismId()) { 20899 composeIdentifier(t, "SubstanceSourceMaterial", "organismId", element.getOrganismId(), -1); 20900 } 20901 if (element.hasOrganismNameElement()) { 20902 composeString(t, "SubstanceSourceMaterial", "organismName", element.getOrganismNameElement(), -1); 20903 } 20904 for (int i = 0; i < element.getParentSubstanceId().size(); i++) { 20905 composeIdentifier(t, "SubstanceSourceMaterial", "parentSubstanceId", element.getParentSubstanceId().get(i), i); 20906 } 20907 for (int i = 0; i < element.getParentSubstanceName().size(); i++) { 20908 composeString(t, "SubstanceSourceMaterial", "parentSubstanceName", element.getParentSubstanceName().get(i), i); 20909 } 20910 for (int i = 0; i < element.getCountryOfOrigin().size(); i++) { 20911 composeCodeableConcept(t, "SubstanceSourceMaterial", "countryOfOrigin", element.getCountryOfOrigin().get(i), i); 20912 } 20913 for (int i = 0; i < element.getGeographicalLocation().size(); i++) { 20914 composeString(t, "SubstanceSourceMaterial", "geographicalLocation", element.getGeographicalLocation().get(i), i); 20915 } 20916 if (element.hasDevelopmentStage()) { 20917 composeCodeableConcept(t, "SubstanceSourceMaterial", "developmentStage", element.getDevelopmentStage(), -1); 20918 } 20919 for (int i = 0; i < element.getFractionDescription().size(); i++) { 20920 composeSubstanceSourceMaterialFractionDescriptionComponent(t, "SubstanceSourceMaterial", "fractionDescription", element.getFractionDescription().get(i), i); 20921 } 20922 if (element.hasOrganism()) { 20923 composeSubstanceSourceMaterialOrganismComponent(t, "SubstanceSourceMaterial", "organism", element.getOrganism(), -1); 20924 } 20925 for (int i = 0; i < element.getPartDescription().size(); i++) { 20926 composeSubstanceSourceMaterialPartDescriptionComponent(t, "SubstanceSourceMaterial", "partDescription", element.getPartDescription().get(i), i); 20927 } 20928 } 20929 20930 protected void composeSubstanceSourceMaterialFractionDescriptionComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialFractionDescriptionComponent element, int index) { 20931 if (element == null) 20932 return; 20933 Complex t; 20934 if (Utilities.noString(parentType)) 20935 t = parent; 20936 else { 20937 t = parent.predicate("fhir:"+parentType+'.'+name); 20938 } 20939 composeBackboneElement(t, "fractionDescription", name, element, index); 20940 if (element.hasFractionElement()) { 20941 composeString(t, "SubstanceSourceMaterialFractionDescriptionComponent", "fraction", element.getFractionElement(), -1); 20942 } 20943 if (element.hasMaterialType()) { 20944 composeCodeableConcept(t, "SubstanceSourceMaterialFractionDescriptionComponent", "materialType", element.getMaterialType(), -1); 20945 } 20946 } 20947 20948 protected void composeSubstanceSourceMaterialOrganismComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismComponent element, int index) { 20949 if (element == null) 20950 return; 20951 Complex t; 20952 if (Utilities.noString(parentType)) 20953 t = parent; 20954 else { 20955 t = parent.predicate("fhir:"+parentType+'.'+name); 20956 } 20957 composeBackboneElement(t, "organism", name, element, index); 20958 if (element.hasFamily()) { 20959 composeCodeableConcept(t, "SubstanceSourceMaterialOrganismComponent", "family", element.getFamily(), -1); 20960 } 20961 if (element.hasGenus()) { 20962 composeCodeableConcept(t, "SubstanceSourceMaterialOrganismComponent", "genus", element.getGenus(), -1); 20963 } 20964 if (element.hasSpecies()) { 20965 composeCodeableConcept(t, "SubstanceSourceMaterialOrganismComponent", "species", element.getSpecies(), -1); 20966 } 20967 if (element.hasIntraspecificType()) { 20968 composeCodeableConcept(t, "SubstanceSourceMaterialOrganismComponent", "intraspecificType", element.getIntraspecificType(), -1); 20969 } 20970 if (element.hasIntraspecificDescriptionElement()) { 20971 composeString(t, "SubstanceSourceMaterialOrganismComponent", "intraspecificDescription", element.getIntraspecificDescriptionElement(), -1); 20972 } 20973 for (int i = 0; i < element.getAuthor().size(); i++) { 20974 composeSubstanceSourceMaterialOrganismAuthorComponent(t, "SubstanceSourceMaterialOrganismComponent", "author", element.getAuthor().get(i), i); 20975 } 20976 if (element.hasHybrid()) { 20977 composeSubstanceSourceMaterialOrganismHybridComponent(t, "SubstanceSourceMaterialOrganismComponent", "hybrid", element.getHybrid(), -1); 20978 } 20979 if (element.hasOrganismGeneral()) { 20980 composeSubstanceSourceMaterialOrganismOrganismGeneralComponent(t, "SubstanceSourceMaterialOrganismComponent", "organismGeneral", element.getOrganismGeneral(), -1); 20981 } 20982 } 20983 20984 protected void composeSubstanceSourceMaterialOrganismAuthorComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismAuthorComponent element, int index) { 20985 if (element == null) 20986 return; 20987 Complex t; 20988 if (Utilities.noString(parentType)) 20989 t = parent; 20990 else { 20991 t = parent.predicate("fhir:"+parentType+'.'+name); 20992 } 20993 composeBackboneElement(t, "author", name, element, index); 20994 if (element.hasAuthorType()) { 20995 composeCodeableConcept(t, "SubstanceSourceMaterialOrganismAuthorComponent", "authorType", element.getAuthorType(), -1); 20996 } 20997 if (element.hasAuthorDescriptionElement()) { 20998 composeString(t, "SubstanceSourceMaterialOrganismAuthorComponent", "authorDescription", element.getAuthorDescriptionElement(), -1); 20999 } 21000 } 21001 21002 protected void composeSubstanceSourceMaterialOrganismHybridComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismHybridComponent element, int index) { 21003 if (element == null) 21004 return; 21005 Complex t; 21006 if (Utilities.noString(parentType)) 21007 t = parent; 21008 else { 21009 t = parent.predicate("fhir:"+parentType+'.'+name); 21010 } 21011 composeBackboneElement(t, "hybrid", name, element, index); 21012 if (element.hasMaternalOrganismIdElement()) { 21013 composeString(t, "SubstanceSourceMaterialOrganismHybridComponent", "maternalOrganismId", element.getMaternalOrganismIdElement(), -1); 21014 } 21015 if (element.hasMaternalOrganismNameElement()) { 21016 composeString(t, "SubstanceSourceMaterialOrganismHybridComponent", "maternalOrganismName", element.getMaternalOrganismNameElement(), -1); 21017 } 21018 if (element.hasPaternalOrganismIdElement()) { 21019 composeString(t, "SubstanceSourceMaterialOrganismHybridComponent", "paternalOrganismId", element.getPaternalOrganismIdElement(), -1); 21020 } 21021 if (element.hasPaternalOrganismNameElement()) { 21022 composeString(t, "SubstanceSourceMaterialOrganismHybridComponent", "paternalOrganismName", element.getPaternalOrganismNameElement(), -1); 21023 } 21024 if (element.hasHybridType()) { 21025 composeCodeableConcept(t, "SubstanceSourceMaterialOrganismHybridComponent", "hybridType", element.getHybridType(), -1); 21026 } 21027 } 21028 21029 protected void composeSubstanceSourceMaterialOrganismOrganismGeneralComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialOrganismOrganismGeneralComponent element, int index) { 21030 if (element == null) 21031 return; 21032 Complex t; 21033 if (Utilities.noString(parentType)) 21034 t = parent; 21035 else { 21036 t = parent.predicate("fhir:"+parentType+'.'+name); 21037 } 21038 composeBackboneElement(t, "organismGeneral", name, element, index); 21039 if (element.hasKingdom()) { 21040 composeCodeableConcept(t, "SubstanceSourceMaterialOrganismOrganismGeneralComponent", "kingdom", element.getKingdom(), -1); 21041 } 21042 if (element.hasPhylum()) { 21043 composeCodeableConcept(t, "SubstanceSourceMaterialOrganismOrganismGeneralComponent", "phylum", element.getPhylum(), -1); 21044 } 21045 if (element.hasClass_()) { 21046 composeCodeableConcept(t, "SubstanceSourceMaterialOrganismOrganismGeneralComponent", "class", element.getClass_(), -1); 21047 } 21048 if (element.hasOrder()) { 21049 composeCodeableConcept(t, "SubstanceSourceMaterialOrganismOrganismGeneralComponent", "order", element.getOrder(), -1); 21050 } 21051 } 21052 21053 protected void composeSubstanceSourceMaterialPartDescriptionComponent(Complex parent, String parentType, String name, SubstanceSourceMaterial.SubstanceSourceMaterialPartDescriptionComponent element, int index) { 21054 if (element == null) 21055 return; 21056 Complex t; 21057 if (Utilities.noString(parentType)) 21058 t = parent; 21059 else { 21060 t = parent.predicate("fhir:"+parentType+'.'+name); 21061 } 21062 composeBackboneElement(t, "partDescription", name, element, index); 21063 if (element.hasPart()) { 21064 composeCodeableConcept(t, "SubstanceSourceMaterialPartDescriptionComponent", "part", element.getPart(), -1); 21065 } 21066 if (element.hasPartLocation()) { 21067 composeCodeableConcept(t, "SubstanceSourceMaterialPartDescriptionComponent", "partLocation", element.getPartLocation(), -1); 21068 } 21069 } 21070 21071 protected void composeSupplyDelivery(Complex parent, String parentType, String name, SupplyDelivery element, int index) { 21072 if (element == null) 21073 return; 21074 Complex t; 21075 if (Utilities.noString(parentType)) 21076 t = parent; 21077 else { 21078 t = parent.predicate("fhir:"+parentType+'.'+name); 21079 } 21080 composeDomainResource(t, "SupplyDelivery", name, element, index); 21081 for (int i = 0; i < element.getIdentifier().size(); i++) { 21082 composeIdentifier(t, "SupplyDelivery", "identifier", element.getIdentifier().get(i), i); 21083 } 21084 for (int i = 0; i < element.getBasedOn().size(); i++) { 21085 composeReference(t, "SupplyDelivery", "basedOn", element.getBasedOn().get(i), i); 21086 } 21087 for (int i = 0; i < element.getPartOf().size(); i++) { 21088 composeReference(t, "SupplyDelivery", "partOf", element.getPartOf().get(i), i); 21089 } 21090 if (element.hasStatusElement()) { 21091 composeEnum(t, "SupplyDelivery", "status", element.getStatusElement(), -1); 21092 } 21093 if (element.hasPatient()) { 21094 composeReference(t, "SupplyDelivery", "patient", element.getPatient(), -1); 21095 } 21096 if (element.hasType()) { 21097 composeCodeableConcept(t, "SupplyDelivery", "type", element.getType(), -1); 21098 } 21099 if (element.hasSuppliedItem()) { 21100 composeSupplyDeliverySuppliedItemComponent(t, "SupplyDelivery", "suppliedItem", element.getSuppliedItem(), -1); 21101 } 21102 if (element.hasOccurrence()) { 21103 composeType(t, "SupplyDelivery", "occurrence", element.getOccurrence(), -1); 21104 } 21105 if (element.hasSupplier()) { 21106 composeReference(t, "SupplyDelivery", "supplier", element.getSupplier(), -1); 21107 } 21108 if (element.hasDestination()) { 21109 composeReference(t, "SupplyDelivery", "destination", element.getDestination(), -1); 21110 } 21111 for (int i = 0; i < element.getReceiver().size(); i++) { 21112 composeReference(t, "SupplyDelivery", "receiver", element.getReceiver().get(i), i); 21113 } 21114 } 21115 21116 protected void composeSupplyDeliverySuppliedItemComponent(Complex parent, String parentType, String name, SupplyDelivery.SupplyDeliverySuppliedItemComponent element, int index) { 21117 if (element == null) 21118 return; 21119 Complex t; 21120 if (Utilities.noString(parentType)) 21121 t = parent; 21122 else { 21123 t = parent.predicate("fhir:"+parentType+'.'+name); 21124 } 21125 composeBackboneElement(t, "suppliedItem", name, element, index); 21126 if (element.hasQuantity()) { 21127 composeQuantity(t, "SupplyDeliverySuppliedItemComponent", "quantity", element.getQuantity(), -1); 21128 } 21129 if (element.hasItem()) { 21130 composeType(t, "SupplyDeliverySuppliedItemComponent", "item", element.getItem(), -1); 21131 } 21132 } 21133 21134 protected void composeSupplyRequest(Complex parent, String parentType, String name, SupplyRequest element, int index) { 21135 if (element == null) 21136 return; 21137 Complex t; 21138 if (Utilities.noString(parentType)) 21139 t = parent; 21140 else { 21141 t = parent.predicate("fhir:"+parentType+'.'+name); 21142 } 21143 composeDomainResource(t, "SupplyRequest", name, element, index); 21144 for (int i = 0; i < element.getIdentifier().size(); i++) { 21145 composeIdentifier(t, "SupplyRequest", "identifier", element.getIdentifier().get(i), i); 21146 } 21147 if (element.hasStatusElement()) { 21148 composeEnum(t, "SupplyRequest", "status", element.getStatusElement(), -1); 21149 } 21150 if (element.hasCategory()) { 21151 composeCodeableConcept(t, "SupplyRequest", "category", element.getCategory(), -1); 21152 } 21153 if (element.hasPriorityElement()) { 21154 composeEnum(t, "SupplyRequest", "priority", element.getPriorityElement(), -1); 21155 } 21156 if (element.hasItem()) { 21157 composeType(t, "SupplyRequest", "item", element.getItem(), -1); 21158 } 21159 if (element.hasQuantity()) { 21160 composeQuantity(t, "SupplyRequest", "quantity", element.getQuantity(), -1); 21161 } 21162 for (int i = 0; i < element.getParameter().size(); i++) { 21163 composeSupplyRequestParameterComponent(t, "SupplyRequest", "parameter", element.getParameter().get(i), i); 21164 } 21165 if (element.hasOccurrence()) { 21166 composeType(t, "SupplyRequest", "occurrence", element.getOccurrence(), -1); 21167 } 21168 if (element.hasAuthoredOnElement()) { 21169 composeDateTime(t, "SupplyRequest", "authoredOn", element.getAuthoredOnElement(), -1); 21170 } 21171 if (element.hasRequester()) { 21172 composeReference(t, "SupplyRequest", "requester", element.getRequester(), -1); 21173 } 21174 for (int i = 0; i < element.getSupplier().size(); i++) { 21175 composeReference(t, "SupplyRequest", "supplier", element.getSupplier().get(i), i); 21176 } 21177 for (int i = 0; i < element.getReason().size(); i++) { 21178 composeCodeableReference(t, "SupplyRequest", "reason", element.getReason().get(i), i); 21179 } 21180 if (element.hasDeliverFrom()) { 21181 composeReference(t, "SupplyRequest", "deliverFrom", element.getDeliverFrom(), -1); 21182 } 21183 if (element.hasDeliverTo()) { 21184 composeReference(t, "SupplyRequest", "deliverTo", element.getDeliverTo(), -1); 21185 } 21186 } 21187 21188 protected void composeSupplyRequestParameterComponent(Complex parent, String parentType, String name, SupplyRequest.SupplyRequestParameterComponent element, int index) { 21189 if (element == null) 21190 return; 21191 Complex t; 21192 if (Utilities.noString(parentType)) 21193 t = parent; 21194 else { 21195 t = parent.predicate("fhir:"+parentType+'.'+name); 21196 } 21197 composeBackboneElement(t, "parameter", name, element, index); 21198 if (element.hasCode()) { 21199 composeCodeableConcept(t, "SupplyRequestParameterComponent", "code", element.getCode(), -1); 21200 } 21201 if (element.hasValue()) { 21202 composeType(t, "SupplyRequestParameterComponent", "value", element.getValue(), -1); 21203 } 21204 } 21205 21206 protected void composeTask(Complex parent, String parentType, String name, Task element, int index) { 21207 if (element == null) 21208 return; 21209 Complex t; 21210 if (Utilities.noString(parentType)) 21211 t = parent; 21212 else { 21213 t = parent.predicate("fhir:"+parentType+'.'+name); 21214 } 21215 composeDomainResource(t, "Task", name, element, index); 21216 for (int i = 0; i < element.getIdentifier().size(); i++) { 21217 composeIdentifier(t, "Task", "identifier", element.getIdentifier().get(i), i); 21218 } 21219 if (element.hasInstantiatesCanonicalElement()) { 21220 composeCanonical(t, "Task", "instantiatesCanonical", element.getInstantiatesCanonicalElement(), -1); 21221 } 21222 if (element.hasInstantiatesUriElement()) { 21223 composeUri(t, "Task", "instantiatesUri", element.getInstantiatesUriElement(), -1); 21224 } 21225 for (int i = 0; i < element.getBasedOn().size(); i++) { 21226 composeReference(t, "Task", "basedOn", element.getBasedOn().get(i), i); 21227 } 21228 if (element.hasGroupIdentifier()) { 21229 composeIdentifier(t, "Task", "groupIdentifier", element.getGroupIdentifier(), -1); 21230 } 21231 for (int i = 0; i < element.getPartOf().size(); i++) { 21232 composeReference(t, "Task", "partOf", element.getPartOf().get(i), i); 21233 } 21234 if (element.hasStatusElement()) { 21235 composeEnum(t, "Task", "status", element.getStatusElement(), -1); 21236 } 21237 if (element.hasStatusReason()) { 21238 composeCodeableConcept(t, "Task", "statusReason", element.getStatusReason(), -1); 21239 } 21240 if (element.hasBusinessStatus()) { 21241 composeCodeableConcept(t, "Task", "businessStatus", element.getBusinessStatus(), -1); 21242 } 21243 if (element.hasIntentElement()) { 21244 composeEnum(t, "Task", "intent", element.getIntentElement(), -1); 21245 } 21246 if (element.hasPriorityElement()) { 21247 composeEnum(t, "Task", "priority", element.getPriorityElement(), -1); 21248 } 21249 if (element.hasCode()) { 21250 composeCodeableConcept(t, "Task", "code", element.getCode(), -1); 21251 } 21252 if (element.hasDescriptionElement()) { 21253 composeString(t, "Task", "description", element.getDescriptionElement(), -1); 21254 } 21255 if (element.hasFocus()) { 21256 composeReference(t, "Task", "focus", element.getFocus(), -1); 21257 } 21258 if (element.hasFor()) { 21259 composeReference(t, "Task", "for", element.getFor(), -1); 21260 } 21261 if (element.hasEncounter()) { 21262 composeReference(t, "Task", "encounter", element.getEncounter(), -1); 21263 } 21264 if (element.hasExecutionPeriod()) { 21265 composePeriod(t, "Task", "executionPeriod", element.getExecutionPeriod(), -1); 21266 } 21267 if (element.hasAuthoredOnElement()) { 21268 composeDateTime(t, "Task", "authoredOn", element.getAuthoredOnElement(), -1); 21269 } 21270 if (element.hasLastModifiedElement()) { 21271 composeDateTime(t, "Task", "lastModified", element.getLastModifiedElement(), -1); 21272 } 21273 if (element.hasRequester()) { 21274 composeReference(t, "Task", "requester", element.getRequester(), -1); 21275 } 21276 for (int i = 0; i < element.getPerformerType().size(); i++) { 21277 composeCodeableConcept(t, "Task", "performerType", element.getPerformerType().get(i), i); 21278 } 21279 if (element.hasOwner()) { 21280 composeReference(t, "Task", "owner", element.getOwner(), -1); 21281 } 21282 if (element.hasLocation()) { 21283 composeReference(t, "Task", "location", element.getLocation(), -1); 21284 } 21285 if (element.hasReasonCode()) { 21286 composeCodeableConcept(t, "Task", "reasonCode", element.getReasonCode(), -1); 21287 } 21288 if (element.hasReasonReference()) { 21289 composeReference(t, "Task", "reasonReference", element.getReasonReference(), -1); 21290 } 21291 for (int i = 0; i < element.getInsurance().size(); i++) { 21292 composeReference(t, "Task", "insurance", element.getInsurance().get(i), i); 21293 } 21294 for (int i = 0; i < element.getNote().size(); i++) { 21295 composeAnnotation(t, "Task", "note", element.getNote().get(i), i); 21296 } 21297 for (int i = 0; i < element.getRelevantHistory().size(); i++) { 21298 composeReference(t, "Task", "relevantHistory", element.getRelevantHistory().get(i), i); 21299 } 21300 if (element.hasRestriction()) { 21301 composeTaskRestrictionComponent(t, "Task", "restriction", element.getRestriction(), -1); 21302 } 21303 for (int i = 0; i < element.getInput().size(); i++) { 21304 composeTaskParameterComponent(t, "Task", "input", element.getInput().get(i), i); 21305 } 21306 for (int i = 0; i < element.getOutput().size(); i++) { 21307 composeTaskOutputComponent(t, "Task", "output", element.getOutput().get(i), i); 21308 } 21309 } 21310 21311 protected void composeTaskRestrictionComponent(Complex parent, String parentType, String name, Task.TaskRestrictionComponent element, int index) { 21312 if (element == null) 21313 return; 21314 Complex t; 21315 if (Utilities.noString(parentType)) 21316 t = parent; 21317 else { 21318 t = parent.predicate("fhir:"+parentType+'.'+name); 21319 } 21320 composeBackboneElement(t, "restriction", name, element, index); 21321 if (element.hasRepetitionsElement()) { 21322 composePositiveInt(t, "TaskRestrictionComponent", "repetitions", element.getRepetitionsElement(), -1); 21323 } 21324 if (element.hasPeriod()) { 21325 composePeriod(t, "TaskRestrictionComponent", "period", element.getPeriod(), -1); 21326 } 21327 for (int i = 0; i < element.getRecipient().size(); i++) { 21328 composeReference(t, "TaskRestrictionComponent", "recipient", element.getRecipient().get(i), i); 21329 } 21330 } 21331 21332 protected void composeTaskParameterComponent(Complex parent, String parentType, String name, Task.ParameterComponent element, int index) { 21333 if (element == null) 21334 return; 21335 Complex t; 21336 if (Utilities.noString(parentType)) 21337 t = parent; 21338 else { 21339 t = parent.predicate("fhir:"+parentType+'.'+name); 21340 } 21341 composeBackboneElement(t, "input", name, element, index); 21342 if (element.hasType()) { 21343 composeCodeableConcept(t, "ParameterComponent", "type", element.getType(), -1); 21344 } 21345 if (element.hasValue()) { 21346 composeType(t, "ParameterComponent", "value", element.getValue(), -1); 21347 } 21348 } 21349 21350 protected void composeTaskOutputComponent(Complex parent, String parentType, String name, Task.TaskOutputComponent element, int index) { 21351 if (element == null) 21352 return; 21353 Complex t; 21354 if (Utilities.noString(parentType)) 21355 t = parent; 21356 else { 21357 t = parent.predicate("fhir:"+parentType+'.'+name); 21358 } 21359 composeBackboneElement(t, "output", name, element, index); 21360 if (element.hasType()) { 21361 composeCodeableConcept(t, "TaskOutputComponent", "type", element.getType(), -1); 21362 } 21363 if (element.hasValue()) { 21364 composeType(t, "TaskOutputComponent", "value", element.getValue(), -1); 21365 } 21366 } 21367 21368 protected void composeTerminologyCapabilities(Complex parent, String parentType, String name, TerminologyCapabilities element, int index) { 21369 if (element == null) 21370 return; 21371 Complex t; 21372 if (Utilities.noString(parentType)) 21373 t = parent; 21374 else { 21375 t = parent.predicate("fhir:"+parentType+'.'+name); 21376 } 21377 composeCanonicalResource(t, "TerminologyCapabilities", name, element, index); 21378 if (element.hasUrlElement()) { 21379 composeUri(t, "TerminologyCapabilities", "url", element.getUrlElement(), -1); 21380 } 21381 if (element.hasVersionElement()) { 21382 composeString(t, "TerminologyCapabilities", "version", element.getVersionElement(), -1); 21383 } 21384 if (element.hasNameElement()) { 21385 composeString(t, "TerminologyCapabilities", "name", element.getNameElement(), -1); 21386 } 21387 if (element.hasTitleElement()) { 21388 composeString(t, "TerminologyCapabilities", "title", element.getTitleElement(), -1); 21389 } 21390 if (element.hasStatusElement()) { 21391 composeEnum(t, "TerminologyCapabilities", "status", element.getStatusElement(), -1); 21392 } 21393 if (element.hasExperimentalElement()) { 21394 composeBoolean(t, "TerminologyCapabilities", "experimental", element.getExperimentalElement(), -1); 21395 } 21396 if (element.hasDateElement()) { 21397 composeDateTime(t, "TerminologyCapabilities", "date", element.getDateElement(), -1); 21398 } 21399 if (element.hasPublisherElement()) { 21400 composeString(t, "TerminologyCapabilities", "publisher", element.getPublisherElement(), -1); 21401 } 21402 for (int i = 0; i < element.getContact().size(); i++) { 21403 composeContactDetail(t, "TerminologyCapabilities", "contact", element.getContact().get(i), i); 21404 } 21405 if (element.hasDescriptionElement()) { 21406 composeMarkdown(t, "TerminologyCapabilities", "description", element.getDescriptionElement(), -1); 21407 } 21408 for (int i = 0; i < element.getUseContext().size(); i++) { 21409 composeUsageContext(t, "TerminologyCapabilities", "useContext", element.getUseContext().get(i), i); 21410 } 21411 for (int i = 0; i < element.getJurisdiction().size(); i++) { 21412 composeCodeableConcept(t, "TerminologyCapabilities", "jurisdiction", element.getJurisdiction().get(i), i); 21413 } 21414 if (element.hasPurposeElement()) { 21415 composeMarkdown(t, "TerminologyCapabilities", "purpose", element.getPurposeElement(), -1); 21416 } 21417 if (element.hasCopyrightElement()) { 21418 composeMarkdown(t, "TerminologyCapabilities", "copyright", element.getCopyrightElement(), -1); 21419 } 21420 if (element.hasKindElement()) { 21421 composeEnum(t, "TerminologyCapabilities", "kind", element.getKindElement(), -1); 21422 } 21423 if (element.hasSoftware()) { 21424 composeTerminologyCapabilitiesSoftwareComponent(t, "TerminologyCapabilities", "software", element.getSoftware(), -1); 21425 } 21426 if (element.hasImplementation()) { 21427 composeTerminologyCapabilitiesImplementationComponent(t, "TerminologyCapabilities", "implementation", element.getImplementation(), -1); 21428 } 21429 if (element.hasLockedDateElement()) { 21430 composeBoolean(t, "TerminologyCapabilities", "lockedDate", element.getLockedDateElement(), -1); 21431 } 21432 for (int i = 0; i < element.getCodeSystem().size(); i++) { 21433 composeTerminologyCapabilitiesCodeSystemComponent(t, "TerminologyCapabilities", "codeSystem", element.getCodeSystem().get(i), i); 21434 } 21435 if (element.hasExpansion()) { 21436 composeTerminologyCapabilitiesExpansionComponent(t, "TerminologyCapabilities", "expansion", element.getExpansion(), -1); 21437 } 21438 if (element.hasCodeSearchElement()) { 21439 composeEnum(t, "TerminologyCapabilities", "codeSearch", element.getCodeSearchElement(), -1); 21440 } 21441 if (element.hasValidateCode()) { 21442 composeTerminologyCapabilitiesValidateCodeComponent(t, "TerminologyCapabilities", "validateCode", element.getValidateCode(), -1); 21443 } 21444 if (element.hasTranslation()) { 21445 composeTerminologyCapabilitiesTranslationComponent(t, "TerminologyCapabilities", "translation", element.getTranslation(), -1); 21446 } 21447 if (element.hasClosure()) { 21448 composeTerminologyCapabilitiesClosureComponent(t, "TerminologyCapabilities", "closure", element.getClosure(), -1); 21449 } 21450 } 21451 21452 protected void composeTerminologyCapabilitiesSoftwareComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesSoftwareComponent element, int index) { 21453 if (element == null) 21454 return; 21455 Complex t; 21456 if (Utilities.noString(parentType)) 21457 t = parent; 21458 else { 21459 t = parent.predicate("fhir:"+parentType+'.'+name); 21460 } 21461 composeBackboneElement(t, "software", name, element, index); 21462 if (element.hasNameElement()) { 21463 composeString(t, "TerminologyCapabilitiesSoftwareComponent", "name", element.getNameElement(), -1); 21464 } 21465 if (element.hasVersionElement()) { 21466 composeString(t, "TerminologyCapabilitiesSoftwareComponent", "version", element.getVersionElement(), -1); 21467 } 21468 } 21469 21470 protected void composeTerminologyCapabilitiesImplementationComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesImplementationComponent element, int index) { 21471 if (element == null) 21472 return; 21473 Complex t; 21474 if (Utilities.noString(parentType)) 21475 t = parent; 21476 else { 21477 t = parent.predicate("fhir:"+parentType+'.'+name); 21478 } 21479 composeBackboneElement(t, "implementation", name, element, index); 21480 if (element.hasDescriptionElement()) { 21481 composeString(t, "TerminologyCapabilitiesImplementationComponent", "description", element.getDescriptionElement(), -1); 21482 } 21483 if (element.hasUrlElement()) { 21484 composeUrl(t, "TerminologyCapabilitiesImplementationComponent", "url", element.getUrlElement(), -1); 21485 } 21486 } 21487 21488 protected void composeTerminologyCapabilitiesCodeSystemComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemComponent element, int index) { 21489 if (element == null) 21490 return; 21491 Complex t; 21492 if (Utilities.noString(parentType)) 21493 t = parent; 21494 else { 21495 t = parent.predicate("fhir:"+parentType+'.'+name); 21496 } 21497 composeBackboneElement(t, "codeSystem", name, element, index); 21498 if (element.hasUriElement()) { 21499 composeCanonical(t, "TerminologyCapabilitiesCodeSystemComponent", "uri", element.getUriElement(), -1); 21500 } 21501 for (int i = 0; i < element.getVersion().size(); i++) { 21502 composeTerminologyCapabilitiesCodeSystemVersionComponent(t, "TerminologyCapabilitiesCodeSystemComponent", "version", element.getVersion().get(i), i); 21503 } 21504 if (element.hasSubsumptionElement()) { 21505 composeBoolean(t, "TerminologyCapabilitiesCodeSystemComponent", "subsumption", element.getSubsumptionElement(), -1); 21506 } 21507 } 21508 21509 protected void composeTerminologyCapabilitiesCodeSystemVersionComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemVersionComponent element, int index) { 21510 if (element == null) 21511 return; 21512 Complex t; 21513 if (Utilities.noString(parentType)) 21514 t = parent; 21515 else { 21516 t = parent.predicate("fhir:"+parentType+'.'+name); 21517 } 21518 composeBackboneElement(t, "version", name, element, index); 21519 if (element.hasCodeElement()) { 21520 composeString(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "code", element.getCodeElement(), -1); 21521 } 21522 if (element.hasIsDefaultElement()) { 21523 composeBoolean(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "isDefault", element.getIsDefaultElement(), -1); 21524 } 21525 if (element.hasCompositionalElement()) { 21526 composeBoolean(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "compositional", element.getCompositionalElement(), -1); 21527 } 21528 for (int i = 0; i < element.getLanguage().size(); i++) { 21529 composeCode(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "language", element.getLanguage().get(i), i); 21530 } 21531 for (int i = 0; i < element.getFilter().size(); i++) { 21532 composeTerminologyCapabilitiesCodeSystemVersionFilterComponent(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "filter", element.getFilter().get(i), i); 21533 } 21534 for (int i = 0; i < element.getProperty().size(); i++) { 21535 composeCode(t, "TerminologyCapabilitiesCodeSystemVersionComponent", "property", element.getProperty().get(i), i); 21536 } 21537 } 21538 21539 protected void composeTerminologyCapabilitiesCodeSystemVersionFilterComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesCodeSystemVersionFilterComponent element, int index) { 21540 if (element == null) 21541 return; 21542 Complex t; 21543 if (Utilities.noString(parentType)) 21544 t = parent; 21545 else { 21546 t = parent.predicate("fhir:"+parentType+'.'+name); 21547 } 21548 composeBackboneElement(t, "filter", name, element, index); 21549 if (element.hasCodeElement()) { 21550 composeCode(t, "TerminologyCapabilitiesCodeSystemVersionFilterComponent", "code", element.getCodeElement(), -1); 21551 } 21552 for (int i = 0; i < element.getOp().size(); i++) { 21553 composeCode(t, "TerminologyCapabilitiesCodeSystemVersionFilterComponent", "op", element.getOp().get(i), i); 21554 } 21555 } 21556 21557 protected void composeTerminologyCapabilitiesExpansionComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesExpansionComponent element, int index) { 21558 if (element == null) 21559 return; 21560 Complex t; 21561 if (Utilities.noString(parentType)) 21562 t = parent; 21563 else { 21564 t = parent.predicate("fhir:"+parentType+'.'+name); 21565 } 21566 composeBackboneElement(t, "expansion", name, element, index); 21567 if (element.hasHierarchicalElement()) { 21568 composeBoolean(t, "TerminologyCapabilitiesExpansionComponent", "hierarchical", element.getHierarchicalElement(), -1); 21569 } 21570 if (element.hasPagingElement()) { 21571 composeBoolean(t, "TerminologyCapabilitiesExpansionComponent", "paging", element.getPagingElement(), -1); 21572 } 21573 if (element.hasIncompleteElement()) { 21574 composeBoolean(t, "TerminologyCapabilitiesExpansionComponent", "incomplete", element.getIncompleteElement(), -1); 21575 } 21576 for (int i = 0; i < element.getParameter().size(); i++) { 21577 composeTerminologyCapabilitiesExpansionParameterComponent(t, "TerminologyCapabilitiesExpansionComponent", "parameter", element.getParameter().get(i), i); 21578 } 21579 if (element.hasTextFilterElement()) { 21580 composeMarkdown(t, "TerminologyCapabilitiesExpansionComponent", "textFilter", element.getTextFilterElement(), -1); 21581 } 21582 } 21583 21584 protected void composeTerminologyCapabilitiesExpansionParameterComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesExpansionParameterComponent element, int index) { 21585 if (element == null) 21586 return; 21587 Complex t; 21588 if (Utilities.noString(parentType)) 21589 t = parent; 21590 else { 21591 t = parent.predicate("fhir:"+parentType+'.'+name); 21592 } 21593 composeBackboneElement(t, "parameter", name, element, index); 21594 if (element.hasNameElement()) { 21595 composeCode(t, "TerminologyCapabilitiesExpansionParameterComponent", "name", element.getNameElement(), -1); 21596 } 21597 if (element.hasDocumentationElement()) { 21598 composeString(t, "TerminologyCapabilitiesExpansionParameterComponent", "documentation", element.getDocumentationElement(), -1); 21599 } 21600 } 21601 21602 protected void composeTerminologyCapabilitiesValidateCodeComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesValidateCodeComponent element, int index) { 21603 if (element == null) 21604 return; 21605 Complex t; 21606 if (Utilities.noString(parentType)) 21607 t = parent; 21608 else { 21609 t = parent.predicate("fhir:"+parentType+'.'+name); 21610 } 21611 composeBackboneElement(t, "validateCode", name, element, index); 21612 if (element.hasTranslationsElement()) { 21613 composeBoolean(t, "TerminologyCapabilitiesValidateCodeComponent", "translations", element.getTranslationsElement(), -1); 21614 } 21615 } 21616 21617 protected void composeTerminologyCapabilitiesTranslationComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesTranslationComponent element, int index) { 21618 if (element == null) 21619 return; 21620 Complex t; 21621 if (Utilities.noString(parentType)) 21622 t = parent; 21623 else { 21624 t = parent.predicate("fhir:"+parentType+'.'+name); 21625 } 21626 composeBackboneElement(t, "translation", name, element, index); 21627 if (element.hasNeedsMapElement()) { 21628 composeBoolean(t, "TerminologyCapabilitiesTranslationComponent", "needsMap", element.getNeedsMapElement(), -1); 21629 } 21630 } 21631 21632 protected void composeTerminologyCapabilitiesClosureComponent(Complex parent, String parentType, String name, TerminologyCapabilities.TerminologyCapabilitiesClosureComponent element, int index) { 21633 if (element == null) 21634 return; 21635 Complex t; 21636 if (Utilities.noString(parentType)) 21637 t = parent; 21638 else { 21639 t = parent.predicate("fhir:"+parentType+'.'+name); 21640 } 21641 composeBackboneElement(t, "closure", name, element, index); 21642 if (element.hasTranslationElement()) { 21643 composeBoolean(t, "TerminologyCapabilitiesClosureComponent", "translation", element.getTranslationElement(), -1); 21644 } 21645 } 21646 21647 protected void composeTestReport(Complex parent, String parentType, String name, TestReport element, int index) { 21648 if (element == null) 21649 return; 21650 Complex t; 21651 if (Utilities.noString(parentType)) 21652 t = parent; 21653 else { 21654 t = parent.predicate("fhir:"+parentType+'.'+name); 21655 } 21656 composeDomainResource(t, "TestReport", name, element, index); 21657 if (element.hasIdentifier()) { 21658 composeIdentifier(t, "TestReport", "identifier", element.getIdentifier(), -1); 21659 } 21660 if (element.hasNameElement()) { 21661 composeString(t, "TestReport", "name", element.getNameElement(), -1); 21662 } 21663 if (element.hasStatusElement()) { 21664 composeEnum(t, "TestReport", "status", element.getStatusElement(), -1); 21665 } 21666 if (element.hasTestScript()) { 21667 composeReference(t, "TestReport", "testScript", element.getTestScript(), -1); 21668 } 21669 if (element.hasResultElement()) { 21670 composeEnum(t, "TestReport", "result", element.getResultElement(), -1); 21671 } 21672 if (element.hasScoreElement()) { 21673 composeDecimal(t, "TestReport", "score", element.getScoreElement(), -1); 21674 } 21675 if (element.hasTesterElement()) { 21676 composeString(t, "TestReport", "tester", element.getTesterElement(), -1); 21677 } 21678 if (element.hasIssuedElement()) { 21679 composeDateTime(t, "TestReport", "issued", element.getIssuedElement(), -1); 21680 } 21681 for (int i = 0; i < element.getParticipant().size(); i++) { 21682 composeTestReportParticipantComponent(t, "TestReport", "participant", element.getParticipant().get(i), i); 21683 } 21684 if (element.hasSetup()) { 21685 composeTestReportSetupComponent(t, "TestReport", "setup", element.getSetup(), -1); 21686 } 21687 for (int i = 0; i < element.getTest().size(); i++) { 21688 composeTestReportTestComponent(t, "TestReport", "test", element.getTest().get(i), i); 21689 } 21690 if (element.hasTeardown()) { 21691 composeTestReportTeardownComponent(t, "TestReport", "teardown", element.getTeardown(), -1); 21692 } 21693 } 21694 21695 protected void composeTestReportParticipantComponent(Complex parent, String parentType, String name, TestReport.TestReportParticipantComponent element, int index) { 21696 if (element == null) 21697 return; 21698 Complex t; 21699 if (Utilities.noString(parentType)) 21700 t = parent; 21701 else { 21702 t = parent.predicate("fhir:"+parentType+'.'+name); 21703 } 21704 composeBackboneElement(t, "participant", name, element, index); 21705 if (element.hasTypeElement()) { 21706 composeEnum(t, "TestReportParticipantComponent", "type", element.getTypeElement(), -1); 21707 } 21708 if (element.hasUriElement()) { 21709 composeUri(t, "TestReportParticipantComponent", "uri", element.getUriElement(), -1); 21710 } 21711 if (element.hasDisplayElement()) { 21712 composeString(t, "TestReportParticipantComponent", "display", element.getDisplayElement(), -1); 21713 } 21714 } 21715 21716 protected void composeTestReportSetupComponent(Complex parent, String parentType, String name, TestReport.TestReportSetupComponent element, int index) { 21717 if (element == null) 21718 return; 21719 Complex t; 21720 if (Utilities.noString(parentType)) 21721 t = parent; 21722 else { 21723 t = parent.predicate("fhir:"+parentType+'.'+name); 21724 } 21725 composeBackboneElement(t, "setup", name, element, index); 21726 for (int i = 0; i < element.getAction().size(); i++) { 21727 composeTestReportSetupActionComponent(t, "TestReportSetupComponent", "action", element.getAction().get(i), i); 21728 } 21729 } 21730 21731 protected void composeTestReportSetupActionComponent(Complex parent, String parentType, String name, TestReport.SetupActionComponent element, int index) { 21732 if (element == null) 21733 return; 21734 Complex t; 21735 if (Utilities.noString(parentType)) 21736 t = parent; 21737 else { 21738 t = parent.predicate("fhir:"+parentType+'.'+name); 21739 } 21740 composeBackboneElement(t, "action", name, element, index); 21741 if (element.hasOperation()) { 21742 composeTestReportSetupActionOperationComponent(t, "SetupActionComponent", "operation", element.getOperation(), -1); 21743 } 21744 if (element.hasAssert()) { 21745 composeTestReportSetupActionAssertComponent(t, "SetupActionComponent", "assert", element.getAssert(), -1); 21746 } 21747 } 21748 21749 protected void composeTestReportSetupActionOperationComponent(Complex parent, String parentType, String name, TestReport.SetupActionOperationComponent element, int index) { 21750 if (element == null) 21751 return; 21752 Complex t; 21753 if (Utilities.noString(parentType)) 21754 t = parent; 21755 else { 21756 t = parent.predicate("fhir:"+parentType+'.'+name); 21757 } 21758 composeBackboneElement(t, "operation", name, element, index); 21759 if (element.hasResultElement()) { 21760 composeEnum(t, "SetupActionOperationComponent", "result", element.getResultElement(), -1); 21761 } 21762 if (element.hasMessageElement()) { 21763 composeMarkdown(t, "SetupActionOperationComponent", "message", element.getMessageElement(), -1); 21764 } 21765 if (element.hasDetailElement()) { 21766 composeUri(t, "SetupActionOperationComponent", "detail", element.getDetailElement(), -1); 21767 } 21768 } 21769 21770 protected void composeTestReportSetupActionAssertComponent(Complex parent, String parentType, String name, TestReport.SetupActionAssertComponent element, int index) { 21771 if (element == null) 21772 return; 21773 Complex t; 21774 if (Utilities.noString(parentType)) 21775 t = parent; 21776 else { 21777 t = parent.predicate("fhir:"+parentType+'.'+name); 21778 } 21779 composeBackboneElement(t, "assert", name, element, index); 21780 if (element.hasResultElement()) { 21781 composeEnum(t, "SetupActionAssertComponent", "result", element.getResultElement(), -1); 21782 } 21783 if (element.hasMessageElement()) { 21784 composeMarkdown(t, "SetupActionAssertComponent", "message", element.getMessageElement(), -1); 21785 } 21786 if (element.hasDetailElement()) { 21787 composeString(t, "SetupActionAssertComponent", "detail", element.getDetailElement(), -1); 21788 } 21789 } 21790 21791 protected void composeTestReportTestComponent(Complex parent, String parentType, String name, TestReport.TestReportTestComponent element, int index) { 21792 if (element == null) 21793 return; 21794 Complex t; 21795 if (Utilities.noString(parentType)) 21796 t = parent; 21797 else { 21798 t = parent.predicate("fhir:"+parentType+'.'+name); 21799 } 21800 composeBackboneElement(t, "test", name, element, index); 21801 if (element.hasNameElement()) { 21802 composeString(t, "TestReportTestComponent", "name", element.getNameElement(), -1); 21803 } 21804 if (element.hasDescriptionElement()) { 21805 composeString(t, "TestReportTestComponent", "description", element.getDescriptionElement(), -1); 21806 } 21807 for (int i = 0; i < element.getAction().size(); i++) { 21808 composeTestReportTestActionComponent(t, "TestReportTestComponent", "action", element.getAction().get(i), i); 21809 } 21810 } 21811 21812 protected void composeTestReportTestActionComponent(Complex parent, String parentType, String name, TestReport.TestActionComponent element, int index) { 21813 if (element == null) 21814 return; 21815 Complex t; 21816 if (Utilities.noString(parentType)) 21817 t = parent; 21818 else { 21819 t = parent.predicate("fhir:"+parentType+'.'+name); 21820 } 21821 composeBackboneElement(t, "action", name, element, index); 21822 if (element.hasOperation()) { 21823 composeTestReportSetupActionOperationComponent(t, "TestActionComponent", "operation", element.getOperation(), -1); 21824 } 21825 if (element.hasAssert()) { 21826 composeTestReportSetupActionAssertComponent(t, "TestActionComponent", "assert", element.getAssert(), -1); 21827 } 21828 } 21829 21830 protected void composeTestReportTeardownComponent(Complex parent, String parentType, String name, TestReport.TestReportTeardownComponent element, int index) { 21831 if (element == null) 21832 return; 21833 Complex t; 21834 if (Utilities.noString(parentType)) 21835 t = parent; 21836 else { 21837 t = parent.predicate("fhir:"+parentType+'.'+name); 21838 } 21839 composeBackboneElement(t, "teardown", name, element, index); 21840 for (int i = 0; i < element.getAction().size(); i++) { 21841 composeTestReportTeardownActionComponent(t, "TestReportTeardownComponent", "action", element.getAction().get(i), i); 21842 } 21843 } 21844 21845 protected void composeTestReportTeardownActionComponent(Complex parent, String parentType, String name, TestReport.TeardownActionComponent element, int index) { 21846 if (element == null) 21847 return; 21848 Complex t; 21849 if (Utilities.noString(parentType)) 21850 t = parent; 21851 else { 21852 t = parent.predicate("fhir:"+parentType+'.'+name); 21853 } 21854 composeBackboneElement(t, "action", name, element, index); 21855 if (element.hasOperation()) { 21856 composeTestReportSetupActionOperationComponent(t, "TeardownActionComponent", "operation", element.getOperation(), -1); 21857 } 21858 } 21859 21860 protected void composeTestScript(Complex parent, String parentType, String name, TestScript element, int index) { 21861 if (element == null) 21862 return; 21863 Complex t; 21864 if (Utilities.noString(parentType)) 21865 t = parent; 21866 else { 21867 t = parent.predicate("fhir:"+parentType+'.'+name); 21868 } 21869 composeCanonicalResource(t, "TestScript", name, element, index); 21870 if (element.hasUrlElement()) { 21871 composeUri(t, "TestScript", "url", element.getUrlElement(), -1); 21872 } 21873 if (element.hasIdentifier()) { 21874 composeIdentifier(t, "TestScript", "identifier", element.getIdentifierFirstRep(), -1); 21875 } 21876 if (element.hasVersionElement()) { 21877 composeString(t, "TestScript", "version", element.getVersionElement(), -1); 21878 } 21879 if (element.hasNameElement()) { 21880 composeString(t, "TestScript", "name", element.getNameElement(), -1); 21881 } 21882 if (element.hasTitleElement()) { 21883 composeString(t, "TestScript", "title", element.getTitleElement(), -1); 21884 } 21885 if (element.hasStatusElement()) { 21886 composeEnum(t, "TestScript", "status", element.getStatusElement(), -1); 21887 } 21888 if (element.hasExperimentalElement()) { 21889 composeBoolean(t, "TestScript", "experimental", element.getExperimentalElement(), -1); 21890 } 21891 if (element.hasDateElement()) { 21892 composeDateTime(t, "TestScript", "date", element.getDateElement(), -1); 21893 } 21894 if (element.hasPublisherElement()) { 21895 composeString(t, "TestScript", "publisher", element.getPublisherElement(), -1); 21896 } 21897 for (int i = 0; i < element.getContact().size(); i++) { 21898 composeContactDetail(t, "TestScript", "contact", element.getContact().get(i), i); 21899 } 21900 if (element.hasDescriptionElement()) { 21901 composeMarkdown(t, "TestScript", "description", element.getDescriptionElement(), -1); 21902 } 21903 for (int i = 0; i < element.getUseContext().size(); i++) { 21904 composeUsageContext(t, "TestScript", "useContext", element.getUseContext().get(i), i); 21905 } 21906 for (int i = 0; i < element.getJurisdiction().size(); i++) { 21907 composeCodeableConcept(t, "TestScript", "jurisdiction", element.getJurisdiction().get(i), i); 21908 } 21909 if (element.hasPurposeElement()) { 21910 composeMarkdown(t, "TestScript", "purpose", element.getPurposeElement(), -1); 21911 } 21912 if (element.hasCopyrightElement()) { 21913 composeMarkdown(t, "TestScript", "copyright", element.getCopyrightElement(), -1); 21914 } 21915 for (int i = 0; i < element.getOrigin().size(); i++) { 21916 composeTestScriptOriginComponent(t, "TestScript", "origin", element.getOrigin().get(i), i); 21917 } 21918 for (int i = 0; i < element.getDestination().size(); i++) { 21919 composeTestScriptDestinationComponent(t, "TestScript", "destination", element.getDestination().get(i), i); 21920 } 21921 if (element.hasMetadata()) { 21922 composeTestScriptMetadataComponent(t, "TestScript", "metadata", element.getMetadata(), -1); 21923 } 21924 for (int i = 0; i < element.getFixture().size(); i++) { 21925 composeTestScriptFixtureComponent(t, "TestScript", "fixture", element.getFixture().get(i), i); 21926 } 21927 for (int i = 0; i < element.getProfile().size(); i++) { 21928 composeReference(t, "TestScript", "profile", element.getProfile().get(i), i); 21929 } 21930 for (int i = 0; i < element.getVariable().size(); i++) { 21931 composeTestScriptVariableComponent(t, "TestScript", "variable", element.getVariable().get(i), i); 21932 } 21933 if (element.hasSetup()) { 21934 composeTestScriptSetupComponent(t, "TestScript", "setup", element.getSetup(), -1); 21935 } 21936 for (int i = 0; i < element.getTest().size(); i++) { 21937 composeTestScriptTestComponent(t, "TestScript", "test", element.getTest().get(i), i); 21938 } 21939 if (element.hasTeardown()) { 21940 composeTestScriptTeardownComponent(t, "TestScript", "teardown", element.getTeardown(), -1); 21941 } 21942 } 21943 21944 protected void composeTestScriptOriginComponent(Complex parent, String parentType, String name, TestScript.TestScriptOriginComponent element, int index) { 21945 if (element == null) 21946 return; 21947 Complex t; 21948 if (Utilities.noString(parentType)) 21949 t = parent; 21950 else { 21951 t = parent.predicate("fhir:"+parentType+'.'+name); 21952 } 21953 composeBackboneElement(t, "origin", name, element, index); 21954 if (element.hasIndexElement()) { 21955 composeInteger(t, "TestScriptOriginComponent", "index", element.getIndexElement(), -1); 21956 } 21957 if (element.hasProfile()) { 21958 composeCoding(t, "TestScriptOriginComponent", "profile", element.getProfile(), -1); 21959 } 21960 } 21961 21962 protected void composeTestScriptDestinationComponent(Complex parent, String parentType, String name, TestScript.TestScriptDestinationComponent element, int index) { 21963 if (element == null) 21964 return; 21965 Complex t; 21966 if (Utilities.noString(parentType)) 21967 t = parent; 21968 else { 21969 t = parent.predicate("fhir:"+parentType+'.'+name); 21970 } 21971 composeBackboneElement(t, "destination", name, element, index); 21972 if (element.hasIndexElement()) { 21973 composeInteger(t, "TestScriptDestinationComponent", "index", element.getIndexElement(), -1); 21974 } 21975 if (element.hasProfile()) { 21976 composeCoding(t, "TestScriptDestinationComponent", "profile", element.getProfile(), -1); 21977 } 21978 } 21979 21980 protected void composeTestScriptMetadataComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataComponent element, int index) { 21981 if (element == null) 21982 return; 21983 Complex t; 21984 if (Utilities.noString(parentType)) 21985 t = parent; 21986 else { 21987 t = parent.predicate("fhir:"+parentType+'.'+name); 21988 } 21989 composeBackboneElement(t, "metadata", name, element, index); 21990 for (int i = 0; i < element.getLink().size(); i++) { 21991 composeTestScriptMetadataLinkComponent(t, "TestScriptMetadataComponent", "link", element.getLink().get(i), i); 21992 } 21993 for (int i = 0; i < element.getCapability().size(); i++) { 21994 composeTestScriptMetadataCapabilityComponent(t, "TestScriptMetadataComponent", "capability", element.getCapability().get(i), i); 21995 } 21996 } 21997 21998 protected void composeTestScriptMetadataLinkComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataLinkComponent element, int index) { 21999 if (element == null) 22000 return; 22001 Complex t; 22002 if (Utilities.noString(parentType)) 22003 t = parent; 22004 else { 22005 t = parent.predicate("fhir:"+parentType+'.'+name); 22006 } 22007 composeBackboneElement(t, "link", name, element, index); 22008 if (element.hasUrlElement()) { 22009 composeUri(t, "TestScriptMetadataLinkComponent", "url", element.getUrlElement(), -1); 22010 } 22011 if (element.hasDescriptionElement()) { 22012 composeString(t, "TestScriptMetadataLinkComponent", "description", element.getDescriptionElement(), -1); 22013 } 22014 } 22015 22016 protected void composeTestScriptMetadataCapabilityComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataCapabilityComponent element, int index) { 22017 if (element == null) 22018 return; 22019 Complex t; 22020 if (Utilities.noString(parentType)) 22021 t = parent; 22022 else { 22023 t = parent.predicate("fhir:"+parentType+'.'+name); 22024 } 22025 composeBackboneElement(t, "capability", name, element, index); 22026 if (element.hasRequiredElement()) { 22027 composeBoolean(t, "TestScriptMetadataCapabilityComponent", "required", element.getRequiredElement(), -1); 22028 } 22029 if (element.hasValidatedElement()) { 22030 composeBoolean(t, "TestScriptMetadataCapabilityComponent", "validated", element.getValidatedElement(), -1); 22031 } 22032 if (element.hasDescriptionElement()) { 22033 composeString(t, "TestScriptMetadataCapabilityComponent", "description", element.getDescriptionElement(), -1); 22034 } 22035 for (int i = 0; i < element.getOrigin().size(); i++) { 22036 composeInteger(t, "TestScriptMetadataCapabilityComponent", "origin", element.getOrigin().get(i), i); 22037 } 22038 if (element.hasDestinationElement()) { 22039 composeInteger(t, "TestScriptMetadataCapabilityComponent", "destination", element.getDestinationElement(), -1); 22040 } 22041 for (int i = 0; i < element.getLink().size(); i++) { 22042 composeUri(t, "TestScriptMetadataCapabilityComponent", "link", element.getLink().get(i), i); 22043 } 22044 if (element.hasCapabilitiesElement()) { 22045 composeCanonical(t, "TestScriptMetadataCapabilityComponent", "capabilities", element.getCapabilitiesElement(), -1); 22046 } 22047 } 22048 22049 protected void composeTestScriptFixtureComponent(Complex parent, String parentType, String name, TestScript.TestScriptFixtureComponent element, int index) { 22050 if (element == null) 22051 return; 22052 Complex t; 22053 if (Utilities.noString(parentType)) 22054 t = parent; 22055 else { 22056 t = parent.predicate("fhir:"+parentType+'.'+name); 22057 } 22058 composeBackboneElement(t, "fixture", name, element, index); 22059 if (element.hasAutocreateElement()) { 22060 composeBoolean(t, "TestScriptFixtureComponent", "autocreate", element.getAutocreateElement(), -1); 22061 } 22062 if (element.hasAutodeleteElement()) { 22063 composeBoolean(t, "TestScriptFixtureComponent", "autodelete", element.getAutodeleteElement(), -1); 22064 } 22065 if (element.hasResource()) { 22066 composeReference(t, "TestScriptFixtureComponent", "resource", element.getResource(), -1); 22067 } 22068 } 22069 22070 protected void composeTestScriptVariableComponent(Complex parent, String parentType, String name, TestScript.TestScriptVariableComponent element, int index) { 22071 if (element == null) 22072 return; 22073 Complex t; 22074 if (Utilities.noString(parentType)) 22075 t = parent; 22076 else { 22077 t = parent.predicate("fhir:"+parentType+'.'+name); 22078 } 22079 composeBackboneElement(t, "variable", name, element, index); 22080 if (element.hasNameElement()) { 22081 composeString(t, "TestScriptVariableComponent", "name", element.getNameElement(), -1); 22082 } 22083 if (element.hasDefaultValueElement()) { 22084 composeString(t, "TestScriptVariableComponent", "defaultValue", element.getDefaultValueElement(), -1); 22085 } 22086 if (element.hasDescriptionElement()) { 22087 composeString(t, "TestScriptVariableComponent", "description", element.getDescriptionElement(), -1); 22088 } 22089 if (element.hasExpressionElement()) { 22090 composeString(t, "TestScriptVariableComponent", "expression", element.getExpressionElement(), -1); 22091 } 22092 if (element.hasHeaderFieldElement()) { 22093 composeString(t, "TestScriptVariableComponent", "headerField", element.getHeaderFieldElement(), -1); 22094 } 22095 if (element.hasHintElement()) { 22096 composeString(t, "TestScriptVariableComponent", "hint", element.getHintElement(), -1); 22097 } 22098 if (element.hasPathElement()) { 22099 composeString(t, "TestScriptVariableComponent", "path", element.getPathElement(), -1); 22100 } 22101 if (element.hasSourceIdElement()) { 22102 composeId(t, "TestScriptVariableComponent", "sourceId", element.getSourceIdElement(), -1); 22103 } 22104 } 22105 22106 protected void composeTestScriptSetupComponent(Complex parent, String parentType, String name, TestScript.TestScriptSetupComponent element, int index) { 22107 if (element == null) 22108 return; 22109 Complex t; 22110 if (Utilities.noString(parentType)) 22111 t = parent; 22112 else { 22113 t = parent.predicate("fhir:"+parentType+'.'+name); 22114 } 22115 composeBackboneElement(t, "setup", name, element, index); 22116 for (int i = 0; i < element.getAction().size(); i++) { 22117 composeTestScriptSetupActionComponent(t, "TestScriptSetupComponent", "action", element.getAction().get(i), i); 22118 } 22119 } 22120 22121 protected void composeTestScriptSetupActionComponent(Complex parent, String parentType, String name, TestScript.SetupActionComponent element, int index) { 22122 if (element == null) 22123 return; 22124 Complex t; 22125 if (Utilities.noString(parentType)) 22126 t = parent; 22127 else { 22128 t = parent.predicate("fhir:"+parentType+'.'+name); 22129 } 22130 composeBackboneElement(t, "action", name, element, index); 22131 if (element.hasOperation()) { 22132 composeTestScriptSetupActionOperationComponent(t, "SetupActionComponent", "operation", element.getOperation(), -1); 22133 } 22134 if (element.hasAssert()) { 22135 composeTestScriptSetupActionAssertComponent(t, "SetupActionComponent", "assert", element.getAssert(), -1); 22136 } 22137 } 22138 22139 protected void composeTestScriptSetupActionOperationComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationComponent element, int index) { 22140 if (element == null) 22141 return; 22142 Complex t; 22143 if (Utilities.noString(parentType)) 22144 t = parent; 22145 else { 22146 t = parent.predicate("fhir:"+parentType+'.'+name); 22147 } 22148 composeBackboneElement(t, "operation", name, element, index); 22149 if (element.hasType()) { 22150 composeCoding(t, "SetupActionOperationComponent", "type", element.getType(), -1); 22151 } 22152 if (element.hasResourceElement()) { 22153 composeEnum(t, "SetupActionOperationComponent", "resource", element.getResourceElement(), -1); 22154 } 22155 if (element.hasLabelElement()) { 22156 composeString(t, "SetupActionOperationComponent", "label", element.getLabelElement(), -1); 22157 } 22158 if (element.hasDescriptionElement()) { 22159 composeString(t, "SetupActionOperationComponent", "description", element.getDescriptionElement(), -1); 22160 } 22161 if (element.hasAcceptElement()) { 22162 composeCode(t, "SetupActionOperationComponent", "accept", element.getAcceptElement(), -1); 22163 } 22164 if (element.hasContentTypeElement()) { 22165 composeCode(t, "SetupActionOperationComponent", "contentType", element.getContentTypeElement(), -1); 22166 } 22167 if (element.hasDestinationElement()) { 22168 composeInteger(t, "SetupActionOperationComponent", "destination", element.getDestinationElement(), -1); 22169 } 22170 if (element.hasEncodeRequestUrlElement()) { 22171 composeBoolean(t, "SetupActionOperationComponent", "encodeRequestUrl", element.getEncodeRequestUrlElement(), -1); 22172 } 22173 if (element.hasMethodElement()) { 22174 composeEnum(t, "SetupActionOperationComponent", "method", element.getMethodElement(), -1); 22175 } 22176 if (element.hasOriginElement()) { 22177 composeInteger(t, "SetupActionOperationComponent", "origin", element.getOriginElement(), -1); 22178 } 22179 if (element.hasParamsElement()) { 22180 composeString(t, "SetupActionOperationComponent", "params", element.getParamsElement(), -1); 22181 } 22182 for (int i = 0; i < element.getRequestHeader().size(); i++) { 22183 composeTestScriptSetupActionOperationRequestHeaderComponent(t, "SetupActionOperationComponent", "requestHeader", element.getRequestHeader().get(i), i); 22184 } 22185 if (element.hasRequestIdElement()) { 22186 composeId(t, "SetupActionOperationComponent", "requestId", element.getRequestIdElement(), -1); 22187 } 22188 if (element.hasResponseIdElement()) { 22189 composeId(t, "SetupActionOperationComponent", "responseId", element.getResponseIdElement(), -1); 22190 } 22191 if (element.hasSourceIdElement()) { 22192 composeId(t, "SetupActionOperationComponent", "sourceId", element.getSourceIdElement(), -1); 22193 } 22194 if (element.hasTargetIdElement()) { 22195 composeId(t, "SetupActionOperationComponent", "targetId", element.getTargetIdElement(), -1); 22196 } 22197 if (element.hasUrlElement()) { 22198 composeString(t, "SetupActionOperationComponent", "url", element.getUrlElement(), -1); 22199 } 22200 } 22201 22202 protected void composeTestScriptSetupActionOperationRequestHeaderComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationRequestHeaderComponent element, int index) { 22203 if (element == null) 22204 return; 22205 Complex t; 22206 if (Utilities.noString(parentType)) 22207 t = parent; 22208 else { 22209 t = parent.predicate("fhir:"+parentType+'.'+name); 22210 } 22211 composeBackboneElement(t, "requestHeader", name, element, index); 22212 if (element.hasFieldElement()) { 22213 composeString(t, "SetupActionOperationRequestHeaderComponent", "field", element.getFieldElement(), -1); 22214 } 22215 if (element.hasValueElement()) { 22216 composeString(t, "SetupActionOperationRequestHeaderComponent", "value", element.getValueElement(), -1); 22217 } 22218 } 22219 22220 protected void composeTestScriptSetupActionAssertComponent(Complex parent, String parentType, String name, TestScript.SetupActionAssertComponent element, int index) { 22221 if (element == null) 22222 return; 22223 Complex t; 22224 if (Utilities.noString(parentType)) 22225 t = parent; 22226 else { 22227 t = parent.predicate("fhir:"+parentType+'.'+name); 22228 } 22229 composeBackboneElement(t, "assert", name, element, index); 22230 if (element.hasLabelElement()) { 22231 composeString(t, "SetupActionAssertComponent", "label", element.getLabelElement(), -1); 22232 } 22233 if (element.hasDescriptionElement()) { 22234 composeString(t, "SetupActionAssertComponent", "description", element.getDescriptionElement(), -1); 22235 } 22236 if (element.hasDirectionElement()) { 22237 composeEnum(t, "SetupActionAssertComponent", "direction", element.getDirectionElement(), -1); 22238 } 22239 if (element.hasCompareToSourceIdElement()) { 22240 composeString(t, "SetupActionAssertComponent", "compareToSourceId", element.getCompareToSourceIdElement(), -1); 22241 } 22242 if (element.hasCompareToSourceExpressionElement()) { 22243 composeString(t, "SetupActionAssertComponent", "compareToSourceExpression", element.getCompareToSourceExpressionElement(), -1); 22244 } 22245 if (element.hasCompareToSourcePathElement()) { 22246 composeString(t, "SetupActionAssertComponent", "compareToSourcePath", element.getCompareToSourcePathElement(), -1); 22247 } 22248 if (element.hasContentTypeElement()) { 22249 composeCode(t, "SetupActionAssertComponent", "contentType", element.getContentTypeElement(), -1); 22250 } 22251 if (element.hasExpressionElement()) { 22252 composeString(t, "SetupActionAssertComponent", "expression", element.getExpressionElement(), -1); 22253 } 22254 if (element.hasHeaderFieldElement()) { 22255 composeString(t, "SetupActionAssertComponent", "headerField", element.getHeaderFieldElement(), -1); 22256 } 22257 if (element.hasMinimumIdElement()) { 22258 composeString(t, "SetupActionAssertComponent", "minimumId", element.getMinimumIdElement(), -1); 22259 } 22260 if (element.hasNavigationLinksElement()) { 22261 composeBoolean(t, "SetupActionAssertComponent", "navigationLinks", element.getNavigationLinksElement(), -1); 22262 } 22263 if (element.hasOperatorElement()) { 22264 composeEnum(t, "SetupActionAssertComponent", "operator", element.getOperatorElement(), -1); 22265 } 22266 if (element.hasPathElement()) { 22267 composeString(t, "SetupActionAssertComponent", "path", element.getPathElement(), -1); 22268 } 22269 if (element.hasRequestMethodElement()) { 22270 composeEnum(t, "SetupActionAssertComponent", "requestMethod", element.getRequestMethodElement(), -1); 22271 } 22272 if (element.hasRequestURLElement()) { 22273 composeString(t, "SetupActionAssertComponent", "requestURL", element.getRequestURLElement(), -1); 22274 } 22275 if (element.hasResourceElement()) { 22276 composeEnum(t, "SetupActionAssertComponent", "resource", element.getResourceElement(), -1); 22277 } 22278 if (element.hasResponseElement()) { 22279 composeEnum(t, "SetupActionAssertComponent", "response", element.getResponseElement(), -1); 22280 } 22281 if (element.hasResponseCodeElement()) { 22282 composeString(t, "SetupActionAssertComponent", "responseCode", element.getResponseCodeElement(), -1); 22283 } 22284 if (element.hasSourceIdElement()) { 22285 composeId(t, "SetupActionAssertComponent", "sourceId", element.getSourceIdElement(), -1); 22286 } 22287 if (element.hasValidateProfileIdElement()) { 22288 composeId(t, "SetupActionAssertComponent", "validateProfileId", element.getValidateProfileIdElement(), -1); 22289 } 22290 if (element.hasValueElement()) { 22291 composeString(t, "SetupActionAssertComponent", "value", element.getValueElement(), -1); 22292 } 22293 if (element.hasWarningOnlyElement()) { 22294 composeBoolean(t, "SetupActionAssertComponent", "warningOnly", element.getWarningOnlyElement(), -1); 22295 } 22296 } 22297 22298 protected void composeTestScriptTestComponent(Complex parent, String parentType, String name, TestScript.TestScriptTestComponent element, int index) { 22299 if (element == null) 22300 return; 22301 Complex t; 22302 if (Utilities.noString(parentType)) 22303 t = parent; 22304 else { 22305 t = parent.predicate("fhir:"+parentType+'.'+name); 22306 } 22307 composeBackboneElement(t, "test", name, element, index); 22308 if (element.hasNameElement()) { 22309 composeString(t, "TestScriptTestComponent", "name", element.getNameElement(), -1); 22310 } 22311 if (element.hasDescriptionElement()) { 22312 composeString(t, "TestScriptTestComponent", "description", element.getDescriptionElement(), -1); 22313 } 22314 for (int i = 0; i < element.getAction().size(); i++) { 22315 composeTestScriptTestActionComponent(t, "TestScriptTestComponent", "action", element.getAction().get(i), i); 22316 } 22317 } 22318 22319 protected void composeTestScriptTestActionComponent(Complex parent, String parentType, String name, TestScript.TestActionComponent element, int index) { 22320 if (element == null) 22321 return; 22322 Complex t; 22323 if (Utilities.noString(parentType)) 22324 t = parent; 22325 else { 22326 t = parent.predicate("fhir:"+parentType+'.'+name); 22327 } 22328 composeBackboneElement(t, "action", name, element, index); 22329 if (element.hasOperation()) { 22330 composeTestScriptSetupActionOperationComponent(t, "TestActionComponent", "operation", element.getOperation(), -1); 22331 } 22332 if (element.hasAssert()) { 22333 composeTestScriptSetupActionAssertComponent(t, "TestActionComponent", "assert", element.getAssert(), -1); 22334 } 22335 } 22336 22337 protected void composeTestScriptTeardownComponent(Complex parent, String parentType, String name, TestScript.TestScriptTeardownComponent element, int index) { 22338 if (element == null) 22339 return; 22340 Complex t; 22341 if (Utilities.noString(parentType)) 22342 t = parent; 22343 else { 22344 t = parent.predicate("fhir:"+parentType+'.'+name); 22345 } 22346 composeBackboneElement(t, "teardown", name, element, index); 22347 for (int i = 0; i < element.getAction().size(); i++) { 22348 composeTestScriptTeardownActionComponent(t, "TestScriptTeardownComponent", "action", element.getAction().get(i), i); 22349 } 22350 } 22351 22352 protected void composeTestScriptTeardownActionComponent(Complex parent, String parentType, String name, TestScript.TeardownActionComponent element, int index) { 22353 if (element == null) 22354 return; 22355 Complex t; 22356 if (Utilities.noString(parentType)) 22357 t = parent; 22358 else { 22359 t = parent.predicate("fhir:"+parentType+'.'+name); 22360 } 22361 composeBackboneElement(t, "action", name, element, index); 22362 if (element.hasOperation()) { 22363 composeTestScriptSetupActionOperationComponent(t, "TeardownActionComponent", "operation", element.getOperation(), -1); 22364 } 22365 } 22366 22367 protected void composeTopic(Complex parent, String parentType, String name, Topic element, int index) { 22368 if (element == null) 22369 return; 22370 Complex t; 22371 if (Utilities.noString(parentType)) 22372 t = parent; 22373 else { 22374 t = parent.predicate("fhir:"+parentType+'.'+name); 22375 } 22376 composeDomainResource(t, "Topic", name, element, index); 22377 if (element.hasUrlElement()) { 22378 composeUri(t, "Topic", "url", element.getUrlElement(), -1); 22379 } 22380 for (int i = 0; i < element.getIdentifier().size(); i++) { 22381 composeIdentifier(t, "Topic", "identifier", element.getIdentifier().get(i), i); 22382 } 22383 if (element.hasVersionElement()) { 22384 composeString(t, "Topic", "version", element.getVersionElement(), -1); 22385 } 22386 if (element.hasTitleElement()) { 22387 composeString(t, "Topic", "title", element.getTitleElement(), -1); 22388 } 22389 for (int i = 0; i < element.getDerivedFromCanonical().size(); i++) { 22390 composeCanonical(t, "Topic", "derivedFromCanonical", element.getDerivedFromCanonical().get(i), i); 22391 } 22392 for (int i = 0; i < element.getDerivedFromUri().size(); i++) { 22393 composeUri(t, "Topic", "derivedFromUri", element.getDerivedFromUri().get(i), i); 22394 } 22395 if (element.hasStatusElement()) { 22396 composeEnum(t, "Topic", "status", element.getStatusElement(), -1); 22397 } 22398 if (element.hasExperimentalElement()) { 22399 composeBoolean(t, "Topic", "experimental", element.getExperimentalElement(), -1); 22400 } 22401 if (element.hasDateElement()) { 22402 composeDateTime(t, "Topic", "date", element.getDateElement(), -1); 22403 } 22404 if (element.hasPublisher()) { 22405 composeReference(t, "Topic", "publisher", element.getPublisher(), -1); 22406 } 22407 for (int i = 0; i < element.getContact().size(); i++) { 22408 composeContactDetail(t, "Topic", "contact", element.getContact().get(i), i); 22409 } 22410 if (element.hasDescriptionElement()) { 22411 composeMarkdown(t, "Topic", "description", element.getDescriptionElement(), -1); 22412 } 22413 for (int i = 0; i < element.getUseContext().size(); i++) { 22414 composeUsageContext(t, "Topic", "useContext", element.getUseContext().get(i), i); 22415 } 22416 for (int i = 0; i < element.getJurisdiction().size(); i++) { 22417 composeCodeableConcept(t, "Topic", "jurisdiction", element.getJurisdiction().get(i), i); 22418 } 22419 if (element.hasPurposeElement()) { 22420 composeMarkdown(t, "Topic", "purpose", element.getPurposeElement(), -1); 22421 } 22422 if (element.hasCopyrightElement()) { 22423 composeMarkdown(t, "Topic", "copyright", element.getCopyrightElement(), -1); 22424 } 22425 if (element.hasApprovalDateElement()) { 22426 composeDate(t, "Topic", "approvalDate", element.getApprovalDateElement(), -1); 22427 } 22428 if (element.hasLastReviewDateElement()) { 22429 composeDate(t, "Topic", "lastReviewDate", element.getLastReviewDateElement(), -1); 22430 } 22431 if (element.hasEffectivePeriod()) { 22432 composePeriod(t, "Topic", "effectivePeriod", element.getEffectivePeriod(), -1); 22433 } 22434 if (element.hasResourceTrigger()) { 22435 composeTopicResourceTriggerComponent(t, "Topic", "resourceTrigger", element.getResourceTrigger(), -1); 22436 } 22437 for (int i = 0; i < element.getCanFilterBy().size(); i++) { 22438 composeTopicCanFilterByComponent(t, "Topic", "canFilterBy", element.getCanFilterBy().get(i), i); 22439 } 22440 } 22441 22442 protected void composeTopicResourceTriggerComponent(Complex parent, String parentType, String name, Topic.TopicResourceTriggerComponent element, int index) { 22443 if (element == null) 22444 return; 22445 Complex t; 22446 if (Utilities.noString(parentType)) 22447 t = parent; 22448 else { 22449 t = parent.predicate("fhir:"+parentType+'.'+name); 22450 } 22451 composeBackboneElement(t, "resourceTrigger", name, element, index); 22452 if (element.hasDescriptionElement()) { 22453 composeString(t, "TopicResourceTriggerComponent", "description", element.getDescriptionElement(), -1); 22454 } 22455 for (int i = 0; i < element.getResourceType().size(); i++) { 22456 composeCode(t, "TopicResourceTriggerComponent", "resourceType", element.getResourceType().get(i), i); 22457 } 22458 for (int i = 0; i < element.getMethodCriteria().size(); i++) { 22459 composeEnum(t, "TopicResourceTriggerComponent", "methodCriteria", element.getMethodCriteria().get(i), i); 22460 } 22461 if (element.hasQueryCriteria()) { 22462 composeTopicResourceTriggerQueryCriteriaComponent(t, "TopicResourceTriggerComponent", "queryCriteria", element.getQueryCriteria(), -1); 22463 } 22464 if (element.hasFhirPathCriteriaElement()) { 22465 composeString(t, "TopicResourceTriggerComponent", "fhirPathCriteria", element.getFhirPathCriteriaElement(), -1); 22466 } 22467 } 22468 22469 protected void composeTopicResourceTriggerQueryCriteriaComponent(Complex parent, String parentType, String name, Topic.TopicResourceTriggerQueryCriteriaComponent element, int index) { 22470 if (element == null) 22471 return; 22472 Complex t; 22473 if (Utilities.noString(parentType)) 22474 t = parent; 22475 else { 22476 t = parent.predicate("fhir:"+parentType+'.'+name); 22477 } 22478 composeBackboneElement(t, "queryCriteria", name, element, index); 22479 if (element.hasPreviousElement()) { 22480 composeString(t, "TopicResourceTriggerQueryCriteriaComponent", "previous", element.getPreviousElement(), -1); 22481 } 22482 if (element.hasCurrentElement()) { 22483 composeString(t, "TopicResourceTriggerQueryCriteriaComponent", "current", element.getCurrentElement(), -1); 22484 } 22485 if (element.hasRequireBothElement()) { 22486 composeBoolean(t, "TopicResourceTriggerQueryCriteriaComponent", "requireBoth", element.getRequireBothElement(), -1); 22487 } 22488 } 22489 22490 protected void composeTopicCanFilterByComponent(Complex parent, String parentType, String name, Topic.TopicCanFilterByComponent element, int index) { 22491 if (element == null) 22492 return; 22493 Complex t; 22494 if (Utilities.noString(parentType)) 22495 t = parent; 22496 else { 22497 t = parent.predicate("fhir:"+parentType+'.'+name); 22498 } 22499 composeBackboneElement(t, "canFilterBy", name, element, index); 22500 if (element.hasNameElement()) { 22501 composeString(t, "TopicCanFilterByComponent", "name", element.getNameElement(), -1); 22502 } 22503 for (int i = 0; i < element.getMatchType().size(); i++) { 22504 composeEnum(t, "TopicCanFilterByComponent", "matchType", element.getMatchType().get(i), i); 22505 } 22506 if (element.hasDocumentationElement()) { 22507 composeMarkdown(t, "TopicCanFilterByComponent", "documentation", element.getDocumentationElement(), -1); 22508 } 22509 } 22510 22511 protected void composeValueSet(Complex parent, String parentType, String name, ValueSet element, int index) { 22512 if (element == null) 22513 return; 22514 Complex t; 22515 if (Utilities.noString(parentType)) 22516 t = parent; 22517 else { 22518 t = parent.predicate("fhir:"+parentType+'.'+name); 22519 } 22520 composeCanonicalResource(t, "ValueSet", name, element, index); 22521 if (element.hasUrlElement()) { 22522 composeUri(t, "ValueSet", "url", element.getUrlElement(), -1); 22523 } 22524 for (int i = 0; i < element.getIdentifier().size(); i++) { 22525 composeIdentifier(t, "ValueSet", "identifier", element.getIdentifier().get(i), i); 22526 } 22527 if (element.hasVersionElement()) { 22528 composeString(t, "ValueSet", "version", element.getVersionElement(), -1); 22529 } 22530 if (element.hasNameElement()) { 22531 composeString(t, "ValueSet", "name", element.getNameElement(), -1); 22532 } 22533 if (element.hasTitleElement()) { 22534 composeString(t, "ValueSet", "title", element.getTitleElement(), -1); 22535 } 22536 if (element.hasStatusElement()) { 22537 composeEnum(t, "ValueSet", "status", element.getStatusElement(), -1); 22538 } 22539 if (element.hasExperimentalElement()) { 22540 composeBoolean(t, "ValueSet", "experimental", element.getExperimentalElement(), -1); 22541 } 22542 if (element.hasDateElement()) { 22543 composeDateTime(t, "ValueSet", "date", element.getDateElement(), -1); 22544 } 22545 if (element.hasPublisherElement()) { 22546 composeString(t, "ValueSet", "publisher", element.getPublisherElement(), -1); 22547 } 22548 for (int i = 0; i < element.getContact().size(); i++) { 22549 composeContactDetail(t, "ValueSet", "contact", element.getContact().get(i), i); 22550 } 22551 if (element.hasDescriptionElement()) { 22552 composeMarkdown(t, "ValueSet", "description", element.getDescriptionElement(), -1); 22553 } 22554 for (int i = 0; i < element.getUseContext().size(); i++) { 22555 composeUsageContext(t, "ValueSet", "useContext", element.getUseContext().get(i), i); 22556 } 22557 for (int i = 0; i < element.getJurisdiction().size(); i++) { 22558 composeCodeableConcept(t, "ValueSet", "jurisdiction", element.getJurisdiction().get(i), i); 22559 } 22560 if (element.hasImmutableElement()) { 22561 composeBoolean(t, "ValueSet", "immutable", element.getImmutableElement(), -1); 22562 } 22563 if (element.hasPurposeElement()) { 22564 composeMarkdown(t, "ValueSet", "purpose", element.getPurposeElement(), -1); 22565 } 22566 if (element.hasCopyrightElement()) { 22567 composeMarkdown(t, "ValueSet", "copyright", element.getCopyrightElement(), -1); 22568 } 22569 if (element.hasCompose()) { 22570 composeValueSetComposeComponent(t, "ValueSet", "compose", element.getCompose(), -1); 22571 } 22572 if (element.hasExpansion()) { 22573 composeValueSetExpansionComponent(t, "ValueSet", "expansion", element.getExpansion(), -1); 22574 } 22575 } 22576 22577 protected void composeValueSetComposeComponent(Complex parent, String parentType, String name, ValueSet.ValueSetComposeComponent element, int index) { 22578 if (element == null) 22579 return; 22580 Complex t; 22581 if (Utilities.noString(parentType)) 22582 t = parent; 22583 else { 22584 t = parent.predicate("fhir:"+parentType+'.'+name); 22585 } 22586 composeBackboneElement(t, "compose", name, element, index); 22587 if (element.hasLockedDateElement()) { 22588 composeDate(t, "ValueSetComposeComponent", "lockedDate", element.getLockedDateElement(), -1); 22589 } 22590 if (element.hasInactiveElement()) { 22591 composeBoolean(t, "ValueSetComposeComponent", "inactive", element.getInactiveElement(), -1); 22592 } 22593 for (int i = 0; i < element.getInclude().size(); i++) { 22594 composeValueSetConceptSetComponent(t, "ValueSetComposeComponent", "include", element.getInclude().get(i), i); 22595 } 22596 for (int i = 0; i < element.getExclude().size(); i++) { 22597 composeValueSetConceptSetComponent(t, "ValueSetComposeComponent", "exclude", element.getExclude().get(i), i); 22598 } 22599 for (int i = 0; i < element.getProperty().size(); i++) { 22600 composeString(t, "ValueSetComposeComponent", "property", element.getProperty().get(i), i); 22601 } 22602 } 22603 22604 protected void composeValueSetConceptSetComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetComponent element, int index) { 22605 if (element == null) 22606 return; 22607 Complex t; 22608 if (Utilities.noString(parentType)) 22609 t = parent; 22610 else { 22611 t = parent.predicate("fhir:"+parentType+'.'+name); 22612 } 22613 composeBackboneElement(t, "include", name, element, index); 22614 if (element.hasSystemElement()) { 22615 composeUri(t, "ConceptSetComponent", "system", element.getSystemElement(), -1); 22616 } 22617 if (element.hasVersionElement()) { 22618 composeString(t, "ConceptSetComponent", "version", element.getVersionElement(), -1); 22619 } 22620 for (int i = 0; i < element.getConcept().size(); i++) { 22621 composeValueSetConceptReferenceComponent(t, "ConceptSetComponent", "concept", element.getConcept().get(i), i); 22622 } 22623 for (int i = 0; i < element.getFilter().size(); i++) { 22624 composeValueSetConceptSetFilterComponent(t, "ConceptSetComponent", "filter", element.getFilter().get(i), i); 22625 } 22626 for (int i = 0; i < element.getValueSet().size(); i++) { 22627 composeCanonical(t, "ConceptSetComponent", "valueSet", element.getValueSet().get(i), i); 22628 } 22629 } 22630 22631 protected void composeValueSetConceptReferenceComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceComponent element, int index) { 22632 if (element == null) 22633 return; 22634 Complex t; 22635 if (Utilities.noString(parentType)) 22636 t = parent; 22637 else { 22638 t = parent.predicate("fhir:"+parentType+'.'+name); 22639 } 22640 composeBackboneElement(t, "concept", name, element, index); 22641 if (element.hasCodeElement()) { 22642 composeCode(t, "ConceptReferenceComponent", "code", element.getCodeElement(), -1); 22643 } 22644 if (element.hasDisplayElement()) { 22645 composeString(t, "ConceptReferenceComponent", "display", element.getDisplayElement(), -1); 22646 } 22647 for (int i = 0; i < element.getDesignation().size(); i++) { 22648 composeValueSetConceptReferenceDesignationComponent(t, "ConceptReferenceComponent", "designation", element.getDesignation().get(i), i); 22649 } 22650 } 22651 22652 protected void composeValueSetConceptReferenceDesignationComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceDesignationComponent element, int index) { 22653 if (element == null) 22654 return; 22655 Complex t; 22656 if (Utilities.noString(parentType)) 22657 t = parent; 22658 else { 22659 t = parent.predicate("fhir:"+parentType+'.'+name); 22660 } 22661 composeBackboneElement(t, "designation", name, element, index); 22662 if (element.hasLanguageElement()) { 22663 composeCode(t, "ConceptReferenceDesignationComponent", "language", element.getLanguageElement(), -1); 22664 } 22665 if (element.hasUse()) { 22666 composeCoding(t, "ConceptReferenceDesignationComponent", "use", element.getUse(), -1); 22667 } 22668 if (element.hasValueElement()) { 22669 composeString(t, "ConceptReferenceDesignationComponent", "value", element.getValueElement(), -1); 22670 } 22671 } 22672 22673 protected void composeValueSetConceptSetFilterComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetFilterComponent element, int index) { 22674 if (element == null) 22675 return; 22676 Complex t; 22677 if (Utilities.noString(parentType)) 22678 t = parent; 22679 else { 22680 t = parent.predicate("fhir:"+parentType+'.'+name); 22681 } 22682 composeBackboneElement(t, "filter", name, element, index); 22683 if (element.hasPropertyElement()) { 22684 composeCode(t, "ConceptSetFilterComponent", "property", element.getPropertyElement(), -1); 22685 } 22686 if (element.hasOpElement()) { 22687 composeEnum(t, "ConceptSetFilterComponent", "op", element.getOpElement(), -1); 22688 } 22689 if (element.hasValueElement()) { 22690 composeString(t, "ConceptSetFilterComponent", "value", element.getValueElement(), -1); 22691 } 22692 } 22693 22694 protected void composeValueSetExpansionComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionComponent element, int index) { 22695 if (element == null) 22696 return; 22697 Complex t; 22698 if (Utilities.noString(parentType)) 22699 t = parent; 22700 else { 22701 t = parent.predicate("fhir:"+parentType+'.'+name); 22702 } 22703 composeBackboneElement(t, "expansion", name, element, index); 22704 if (element.hasIdentifierElement()) { 22705 composeUri(t, "ValueSetExpansionComponent", "identifier", element.getIdentifierElement(), -1); 22706 } 22707 if (element.hasTimestampElement()) { 22708 composeDateTime(t, "ValueSetExpansionComponent", "timestamp", element.getTimestampElement(), -1); 22709 } 22710 if (element.hasTotalElement()) { 22711 composeInteger(t, "ValueSetExpansionComponent", "total", element.getTotalElement(), -1); 22712 } 22713 if (element.hasOffsetElement()) { 22714 composeInteger(t, "ValueSetExpansionComponent", "offset", element.getOffsetElement(), -1); 22715 } 22716 for (int i = 0; i < element.getParameter().size(); i++) { 22717 composeValueSetExpansionParameterComponent(t, "ValueSetExpansionComponent", "parameter", element.getParameter().get(i), i); 22718 } 22719 for (int i = 0; i < element.getProperty().size(); i++) { 22720 composeValueSetExpansionPropertyComponent(t, "ValueSetExpansionComponent", "property", element.getProperty().get(i), i); 22721 } 22722 for (int i = 0; i < element.getContains().size(); i++) { 22723 composeValueSetExpansionContainsComponent(t, "ValueSetExpansionComponent", "contains", element.getContains().get(i), i); 22724 } 22725 } 22726 22727 protected void composeValueSetExpansionParameterComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionParameterComponent element, int index) { 22728 if (element == null) 22729 return; 22730 Complex t; 22731 if (Utilities.noString(parentType)) 22732 t = parent; 22733 else { 22734 t = parent.predicate("fhir:"+parentType+'.'+name); 22735 } 22736 composeBackboneElement(t, "parameter", name, element, index); 22737 if (element.hasNameElement()) { 22738 composeString(t, "ValueSetExpansionParameterComponent", "name", element.getNameElement(), -1); 22739 } 22740 if (element.hasValue()) { 22741 composeType(t, "ValueSetExpansionParameterComponent", "value", element.getValue(), -1); 22742 } 22743 } 22744 22745 protected void composeValueSetExpansionPropertyComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionPropertyComponent element, int index) { 22746 if (element == null) 22747 return; 22748 Complex t; 22749 if (Utilities.noString(parentType)) 22750 t = parent; 22751 else { 22752 t = parent.predicate("fhir:"+parentType+'.'+name); 22753 } 22754 composeBackboneElement(t, "property", name, element, index); 22755 if (element.hasCodeElement()) { 22756 composeCode(t, "ValueSetExpansionPropertyComponent", "code", element.getCodeElement(), -1); 22757 } 22758 if (element.hasUriElement()) { 22759 composeUri(t, "ValueSetExpansionPropertyComponent", "uri", element.getUriElement(), -1); 22760 } 22761 } 22762 22763 protected void composeValueSetExpansionContainsComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionContainsComponent element, int index) { 22764 if (element == null) 22765 return; 22766 Complex t; 22767 if (Utilities.noString(parentType)) 22768 t = parent; 22769 else { 22770 t = parent.predicate("fhir:"+parentType+'.'+name); 22771 } 22772 composeBackboneElement(t, "contains", name, element, index); 22773 if (element.hasSystemElement()) { 22774 composeUri(t, "ValueSetExpansionContainsComponent", "system", element.getSystemElement(), -1); 22775 } 22776 if (element.hasAbstractElement()) { 22777 composeBoolean(t, "ValueSetExpansionContainsComponent", "abstract", element.getAbstractElement(), -1); 22778 } 22779 if (element.hasInactiveElement()) { 22780 composeBoolean(t, "ValueSetExpansionContainsComponent", "inactive", element.getInactiveElement(), -1); 22781 } 22782 if (element.hasVersionElement()) { 22783 composeString(t, "ValueSetExpansionContainsComponent", "version", element.getVersionElement(), -1); 22784 } 22785 if (element.hasCodeElement()) { 22786 composeCode(t, "ValueSetExpansionContainsComponent", "code", element.getCodeElement(), -1); 22787 } 22788 if (element.hasDisplayElement()) { 22789 composeString(t, "ValueSetExpansionContainsComponent", "display", element.getDisplayElement(), -1); 22790 } 22791 for (int i = 0; i < element.getDesignation().size(); i++) { 22792 composeValueSetConceptReferenceDesignationComponent(t, "ValueSetExpansionContainsComponent", "designation", element.getDesignation().get(i), i); 22793 } 22794 for (int i = 0; i < element.getProperty().size(); i++) { 22795 composeValueSetConceptPropertyComponent(t, "ValueSetExpansionContainsComponent", "property", element.getProperty().get(i), i); 22796 } 22797 for (int i = 0; i < element.getContains().size(); i++) { 22798 composeValueSetExpansionContainsComponent(t, "ValueSetExpansionContainsComponent", "contains", element.getContains().get(i), i); 22799 } 22800 } 22801 22802 protected void composeValueSetConceptPropertyComponent(Complex parent, String parentType, String name, ValueSet.ConceptPropertyComponent element, int index) { 22803 if (element == null) 22804 return; 22805 Complex t; 22806 if (Utilities.noString(parentType)) 22807 t = parent; 22808 else { 22809 t = parent.predicate("fhir:"+parentType+'.'+name); 22810 } 22811 composeBackboneElement(t, "property", name, element, index); 22812 if (element.hasCodeElement()) { 22813 composeCode(t, "ConceptPropertyComponent", "code", element.getCodeElement(), -1); 22814 } 22815 if (element.hasValue()) { 22816 composeType(t, "ConceptPropertyComponent", "value", element.getValue(), -1); 22817 } 22818 } 22819 22820 protected void composeVerificationResult(Complex parent, String parentType, String name, VerificationResult element, int index) { 22821 if (element == null) 22822 return; 22823 Complex t; 22824 if (Utilities.noString(parentType)) 22825 t = parent; 22826 else { 22827 t = parent.predicate("fhir:"+parentType+'.'+name); 22828 } 22829 composeDomainResource(t, "VerificationResult", name, element, index); 22830 for (int i = 0; i < element.getTarget().size(); i++) { 22831 composeReference(t, "VerificationResult", "target", element.getTarget().get(i), i); 22832 } 22833 for (int i = 0; i < element.getTargetLocation().size(); i++) { 22834 composeString(t, "VerificationResult", "targetLocation", element.getTargetLocation().get(i), i); 22835 } 22836 if (element.hasNeed()) { 22837 composeCodeableConcept(t, "VerificationResult", "need", element.getNeed(), -1); 22838 } 22839 if (element.hasStatusElement()) { 22840 composeEnum(t, "VerificationResult", "status", element.getStatusElement(), -1); 22841 } 22842 if (element.hasStatusDateElement()) { 22843 composeDateTime(t, "VerificationResult", "statusDate", element.getStatusDateElement(), -1); 22844 } 22845 if (element.hasValidationType()) { 22846 composeCodeableConcept(t, "VerificationResult", "validationType", element.getValidationType(), -1); 22847 } 22848 for (int i = 0; i < element.getValidationProcess().size(); i++) { 22849 composeCodeableConcept(t, "VerificationResult", "validationProcess", element.getValidationProcess().get(i), i); 22850 } 22851 if (element.hasFrequency()) { 22852 composeTiming(t, "VerificationResult", "frequency", element.getFrequency(), -1); 22853 } 22854 if (element.hasLastPerformedElement()) { 22855 composeDateTime(t, "VerificationResult", "lastPerformed", element.getLastPerformedElement(), -1); 22856 } 22857 if (element.hasNextScheduledElement()) { 22858 composeDate(t, "VerificationResult", "nextScheduled", element.getNextScheduledElement(), -1); 22859 } 22860 if (element.hasFailureAction()) { 22861 composeCodeableConcept(t, "VerificationResult", "failureAction", element.getFailureAction(), -1); 22862 } 22863 for (int i = 0; i < element.getPrimarySource().size(); i++) { 22864 composeVerificationResultPrimarySourceComponent(t, "VerificationResult", "primarySource", element.getPrimarySource().get(i), i); 22865 } 22866 if (element.hasAttestation()) { 22867 composeVerificationResultAttestationComponent(t, "VerificationResult", "attestation", element.getAttestation(), -1); 22868 } 22869 for (int i = 0; i < element.getValidator().size(); i++) { 22870 composeVerificationResultValidatorComponent(t, "VerificationResult", "validator", element.getValidator().get(i), i); 22871 } 22872 } 22873 22874 protected void composeVerificationResultPrimarySourceComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultPrimarySourceComponent element, int index) { 22875 if (element == null) 22876 return; 22877 Complex t; 22878 if (Utilities.noString(parentType)) 22879 t = parent; 22880 else { 22881 t = parent.predicate("fhir:"+parentType+'.'+name); 22882 } 22883 composeBackboneElement(t, "primarySource", name, element, index); 22884 if (element.hasWho()) { 22885 composeReference(t, "VerificationResultPrimarySourceComponent", "who", element.getWho(), -1); 22886 } 22887 for (int i = 0; i < element.getType().size(); i++) { 22888 composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "type", element.getType().get(i), i); 22889 } 22890 for (int i = 0; i < element.getCommunicationMethod().size(); i++) { 22891 composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "communicationMethod", element.getCommunicationMethod().get(i), i); 22892 } 22893 if (element.hasValidationStatus()) { 22894 composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "validationStatus", element.getValidationStatus(), -1); 22895 } 22896 if (element.hasValidationDateElement()) { 22897 composeDateTime(t, "VerificationResultPrimarySourceComponent", "validationDate", element.getValidationDateElement(), -1); 22898 } 22899 if (element.hasCanPushUpdates()) { 22900 composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "canPushUpdates", element.getCanPushUpdates(), -1); 22901 } 22902 for (int i = 0; i < element.getPushTypeAvailable().size(); i++) { 22903 composeCodeableConcept(t, "VerificationResultPrimarySourceComponent", "pushTypeAvailable", element.getPushTypeAvailable().get(i), i); 22904 } 22905 } 22906 22907 protected void composeVerificationResultAttestationComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultAttestationComponent element, int index) { 22908 if (element == null) 22909 return; 22910 Complex t; 22911 if (Utilities.noString(parentType)) 22912 t = parent; 22913 else { 22914 t = parent.predicate("fhir:"+parentType+'.'+name); 22915 } 22916 composeBackboneElement(t, "attestation", name, element, index); 22917 if (element.hasWho()) { 22918 composeReference(t, "VerificationResultAttestationComponent", "who", element.getWho(), -1); 22919 } 22920 if (element.hasOnBehalfOf()) { 22921 composeReference(t, "VerificationResultAttestationComponent", "onBehalfOf", element.getOnBehalfOf(), -1); 22922 } 22923 if (element.hasCommunicationMethod()) { 22924 composeCodeableConcept(t, "VerificationResultAttestationComponent", "communicationMethod", element.getCommunicationMethod(), -1); 22925 } 22926 if (element.hasDateElement()) { 22927 composeDate(t, "VerificationResultAttestationComponent", "date", element.getDateElement(), -1); 22928 } 22929 if (element.hasSourceIdentityCertificateElement()) { 22930 composeString(t, "VerificationResultAttestationComponent", "sourceIdentityCertificate", element.getSourceIdentityCertificateElement(), -1); 22931 } 22932 if (element.hasProxyIdentityCertificateElement()) { 22933 composeString(t, "VerificationResultAttestationComponent", "proxyIdentityCertificate", element.getProxyIdentityCertificateElement(), -1); 22934 } 22935 if (element.hasProxySignature()) { 22936 composeSignature(t, "VerificationResultAttestationComponent", "proxySignature", element.getProxySignature(), -1); 22937 } 22938 if (element.hasSourceSignature()) { 22939 composeSignature(t, "VerificationResultAttestationComponent", "sourceSignature", element.getSourceSignature(), -1); 22940 } 22941 } 22942 22943 protected void composeVerificationResultValidatorComponent(Complex parent, String parentType, String name, VerificationResult.VerificationResultValidatorComponent element, int index) { 22944 if (element == null) 22945 return; 22946 Complex t; 22947 if (Utilities.noString(parentType)) 22948 t = parent; 22949 else { 22950 t = parent.predicate("fhir:"+parentType+'.'+name); 22951 } 22952 composeBackboneElement(t, "validator", name, element, index); 22953 if (element.hasOrganization()) { 22954 composeReference(t, "VerificationResultValidatorComponent", "organization", element.getOrganization(), -1); 22955 } 22956 if (element.hasIdentityCertificateElement()) { 22957 composeString(t, "VerificationResultValidatorComponent", "identityCertificate", element.getIdentityCertificateElement(), -1); 22958 } 22959 if (element.hasAttestationSignature()) { 22960 composeSignature(t, "VerificationResultValidatorComponent", "attestationSignature", element.getAttestationSignature(), -1); 22961 } 22962 } 22963 22964 protected void composeVisionPrescription(Complex parent, String parentType, String name, VisionPrescription element, int index) { 22965 if (element == null) 22966 return; 22967 Complex t; 22968 if (Utilities.noString(parentType)) 22969 t = parent; 22970 else { 22971 t = parent.predicate("fhir:"+parentType+'.'+name); 22972 } 22973 composeDomainResource(t, "VisionPrescription", name, element, index); 22974 for (int i = 0; i < element.getIdentifier().size(); i++) { 22975 composeIdentifier(t, "VisionPrescription", "identifier", element.getIdentifier().get(i), i); 22976 } 22977 if (element.hasStatusElement()) { 22978 composeEnum(t, "VisionPrescription", "status", element.getStatusElement(), -1); 22979 } 22980 if (element.hasCreatedElement()) { 22981 composeDateTime(t, "VisionPrescription", "created", element.getCreatedElement(), -1); 22982 } 22983 if (element.hasPatient()) { 22984 composeReference(t, "VisionPrescription", "patient", element.getPatient(), -1); 22985 } 22986 if (element.hasEncounter()) { 22987 composeReference(t, "VisionPrescription", "encounter", element.getEncounter(), -1); 22988 } 22989 if (element.hasDateWrittenElement()) { 22990 composeDateTime(t, "VisionPrescription", "dateWritten", element.getDateWrittenElement(), -1); 22991 } 22992 if (element.hasPrescriber()) { 22993 composeReference(t, "VisionPrescription", "prescriber", element.getPrescriber(), -1); 22994 } 22995 for (int i = 0; i < element.getLensSpecification().size(); i++) { 22996 composeVisionPrescriptionLensSpecificationComponent(t, "VisionPrescription", "lensSpecification", element.getLensSpecification().get(i), i); 22997 } 22998 } 22999 23000 protected void composeVisionPrescriptionLensSpecificationComponent(Complex parent, String parentType, String name, VisionPrescription.VisionPrescriptionLensSpecificationComponent element, int index) { 23001 if (element == null) 23002 return; 23003 Complex t; 23004 if (Utilities.noString(parentType)) 23005 t = parent; 23006 else { 23007 t = parent.predicate("fhir:"+parentType+'.'+name); 23008 } 23009 composeBackboneElement(t, "lensSpecification", name, element, index); 23010 if (element.hasProduct()) { 23011 composeCodeableConcept(t, "VisionPrescriptionLensSpecificationComponent", "product", element.getProduct(), -1); 23012 } 23013 if (element.hasEyeElement()) { 23014 composeEnum(t, "VisionPrescriptionLensSpecificationComponent", "eye", element.getEyeElement(), -1); 23015 } 23016 if (element.hasSphereElement()) { 23017 composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "sphere", element.getSphereElement(), -1); 23018 } 23019 if (element.hasCylinderElement()) { 23020 composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "cylinder", element.getCylinderElement(), -1); 23021 } 23022 if (element.hasAxisElement()) { 23023 composeInteger(t, "VisionPrescriptionLensSpecificationComponent", "axis", element.getAxisElement(), -1); 23024 } 23025 for (int i = 0; i < element.getPrism().size(); i++) { 23026 composeVisionPrescriptionPrismComponent(t, "VisionPrescriptionLensSpecificationComponent", "prism", element.getPrism().get(i), i); 23027 } 23028 if (element.hasAddElement()) { 23029 composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "add", element.getAddElement(), -1); 23030 } 23031 if (element.hasPowerElement()) { 23032 composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "power", element.getPowerElement(), -1); 23033 } 23034 if (element.hasBackCurveElement()) { 23035 composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "backCurve", element.getBackCurveElement(), -1); 23036 } 23037 if (element.hasDiameterElement()) { 23038 composeDecimal(t, "VisionPrescriptionLensSpecificationComponent", "diameter", element.getDiameterElement(), -1); 23039 } 23040 if (element.hasDuration()) { 23041 composeQuantity(t, "VisionPrescriptionLensSpecificationComponent", "duration", element.getDuration(), -1); 23042 } 23043 if (element.hasColorElement()) { 23044 composeString(t, "VisionPrescriptionLensSpecificationComponent", "color", element.getColorElement(), -1); 23045 } 23046 if (element.hasBrandElement()) { 23047 composeString(t, "VisionPrescriptionLensSpecificationComponent", "brand", element.getBrandElement(), -1); 23048 } 23049 for (int i = 0; i < element.getNote().size(); i++) { 23050 composeAnnotation(t, "VisionPrescriptionLensSpecificationComponent", "note", element.getNote().get(i), i); 23051 } 23052 } 23053 23054 protected void composeVisionPrescriptionPrismComponent(Complex parent, String parentType, String name, VisionPrescription.PrismComponent element, int index) { 23055 if (element == null) 23056 return; 23057 Complex t; 23058 if (Utilities.noString(parentType)) 23059 t = parent; 23060 else { 23061 t = parent.predicate("fhir:"+parentType+'.'+name); 23062 } 23063 composeBackboneElement(t, "prism", name, element, index); 23064 if (element.hasAmountElement()) { 23065 composeDecimal(t, "PrismComponent", "amount", element.getAmountElement(), -1); 23066 } 23067 if (element.hasBaseElement()) { 23068 composeEnum(t, "PrismComponent", "base", element.getBaseElement(), -1); 23069 } 23070 } 23071 23072 23073 23074 23075 @Override 23076 protected void composeResource(Complex parent, Resource resource) { 23077 if (parent == null) { 23078 throw new Error("parent == null"); 23079 } else if (resource == null) { 23080 throw new Error("resource == null"); 23081 } else if (resource instanceof Account) { 23082 composeAccount(parent, null, "Account", (Account)resource, -1); 23083 } else if (resource instanceof ActivityDefinition) { 23084 composeActivityDefinition(parent, null, "ActivityDefinition", (ActivityDefinition)resource, -1); 23085 } else if (resource instanceof AdministrableProductDefinition) { 23086 composeAdministrableProductDefinition(parent, null, "AdministrableProductDefinition", (AdministrableProductDefinition)resource, -1); 23087 } else if (resource instanceof AdverseEvent) { 23088 composeAdverseEvent(parent, null, "AdverseEvent", (AdverseEvent)resource, -1); 23089 } else if (resource instanceof AllergyIntolerance) { 23090 composeAllergyIntolerance(parent, null, "AllergyIntolerance", (AllergyIntolerance)resource, -1); 23091 } else if (resource instanceof Appointment) { 23092 composeAppointment(parent, null, "Appointment", (Appointment)resource, -1); 23093 } else if (resource instanceof AppointmentResponse) { 23094 composeAppointmentResponse(parent, null, "AppointmentResponse", (AppointmentResponse)resource, -1); 23095 } else if (resource instanceof AuditEvent) { 23096 composeAuditEvent(parent, null, "AuditEvent", (AuditEvent)resource, -1); 23097 } else if (resource instanceof Basic) { 23098 composeBasic(parent, null, "Basic", (Basic)resource, -1); 23099 } else if (resource instanceof Binary) { 23100 composeBinary(parent, null, "Binary", (Binary)resource, -1); 23101 } else if (resource instanceof BiologicallyDerivedProduct) { 23102 composeBiologicallyDerivedProduct(parent, null, "BiologicallyDerivedProduct", (BiologicallyDerivedProduct)resource, -1); 23103 } else if (resource instanceof BodyStructure) { 23104 composeBodyStructure(parent, null, "BodyStructure", (BodyStructure)resource, -1); 23105 } else if (resource instanceof Bundle) { 23106 composeBundle(parent, null, "Bundle", (Bundle)resource, -1); 23107 } else if (resource instanceof CapabilityStatement) { 23108 composeCapabilityStatement(parent, null, "CapabilityStatement", (CapabilityStatement)resource, -1); 23109 } else if (resource instanceof CapabilityStatement2) { 23110 composeCapabilityStatement2(parent, null, "CapabilityStatement2", (CapabilityStatement2)resource, -1); 23111 } else if (resource instanceof CarePlan) { 23112 composeCarePlan(parent, null, "CarePlan", (CarePlan)resource, -1); 23113 } else if (resource instanceof CareTeam) { 23114 composeCareTeam(parent, null, "CareTeam", (CareTeam)resource, -1); 23115 } else if (resource instanceof CatalogEntry) { 23116 composeCatalogEntry(parent, null, "CatalogEntry", (CatalogEntry)resource, -1); 23117 } else if (resource instanceof ChargeItem) { 23118 composeChargeItem(parent, null, "ChargeItem", (ChargeItem)resource, -1); 23119 } else if (resource instanceof ChargeItemDefinition) { 23120 composeChargeItemDefinition(parent, null, "ChargeItemDefinition", (ChargeItemDefinition)resource, -1); 23121 } else if (resource instanceof Claim) { 23122 composeClaim(parent, null, "Claim", (Claim)resource, -1); 23123 } else if (resource instanceof ClaimResponse) { 23124 composeClaimResponse(parent, null, "ClaimResponse", (ClaimResponse)resource, -1); 23125 } else if (resource instanceof ClinicalImpression) { 23126 composeClinicalImpression(parent, null, "ClinicalImpression", (ClinicalImpression)resource, -1); 23127 } else if (resource instanceof ClinicalUseIssue) { 23128 composeClinicalUseIssue(parent, null, "ClinicalUseIssue", (ClinicalUseIssue)resource, -1); 23129 } else if (resource instanceof CodeSystem) { 23130 composeCodeSystem(parent, null, "CodeSystem", (CodeSystem)resource, -1); 23131 } else if (resource instanceof Communication) { 23132 composeCommunication(parent, null, "Communication", (Communication)resource, -1); 23133 } else if (resource instanceof CommunicationRequest) { 23134 composeCommunicationRequest(parent, null, "CommunicationRequest", (CommunicationRequest)resource, -1); 23135 } else if (resource instanceof CompartmentDefinition) { 23136 composeCompartmentDefinition(parent, null, "CompartmentDefinition", (CompartmentDefinition)resource, -1); 23137 } else if (resource instanceof Composition) { 23138 composeComposition(parent, null, "Composition", (Composition)resource, -1); 23139 } else if (resource instanceof ConceptMap) { 23140 composeConceptMap(parent, null, "ConceptMap", (ConceptMap)resource, -1); 23141 } else if (resource instanceof Condition) { 23142 composeCondition(parent, null, "Condition", (Condition)resource, -1); 23143 } else if (resource instanceof ConditionDefinition) { 23144 composeConditionDefinition(parent, null, "ConditionDefinition", (ConditionDefinition)resource, -1); 23145 } else if (resource instanceof Consent) { 23146 composeConsent(parent, null, "Consent", (Consent)resource, -1); 23147 } else if (resource instanceof Contract) { 23148 composeContract(parent, null, "Contract", (Contract)resource, -1); 23149 } else if (resource instanceof Coverage) { 23150 composeCoverage(parent, null, "Coverage", (Coverage)resource, -1); 23151 } else if (resource instanceof CoverageEligibilityRequest) { 23152 composeCoverageEligibilityRequest(parent, null, "CoverageEligibilityRequest", (CoverageEligibilityRequest)resource, -1); 23153 } else if (resource instanceof CoverageEligibilityResponse) { 23154 composeCoverageEligibilityResponse(parent, null, "CoverageEligibilityResponse", (CoverageEligibilityResponse)resource, -1); 23155 } else if (resource instanceof DetectedIssue) { 23156 composeDetectedIssue(parent, null, "DetectedIssue", (DetectedIssue)resource, -1); 23157 } else if (resource instanceof Device) { 23158 composeDevice(parent, null, "Device", (Device)resource, -1); 23159 } else if (resource instanceof DeviceDefinition) { 23160 composeDeviceDefinition(parent, null, "DeviceDefinition", (DeviceDefinition)resource, -1); 23161 } else if (resource instanceof DeviceMetric) { 23162 composeDeviceMetric(parent, null, "DeviceMetric", (DeviceMetric)resource, -1); 23163 } else if (resource instanceof DeviceRequest) { 23164 composeDeviceRequest(parent, null, "DeviceRequest", (DeviceRequest)resource, -1); 23165 } else if (resource instanceof DeviceUseStatement) { 23166 composeDeviceUseStatement(parent, null, "DeviceUseStatement", (DeviceUseStatement)resource, -1); 23167 } else if (resource instanceof DiagnosticReport) { 23168 composeDiagnosticReport(parent, null, "DiagnosticReport", (DiagnosticReport)resource, -1); 23169 } else if (resource instanceof DocumentManifest) { 23170 composeDocumentManifest(parent, null, "DocumentManifest", (DocumentManifest)resource, -1); 23171 } else if (resource instanceof DocumentReference) { 23172 composeDocumentReference(parent, null, "DocumentReference", (DocumentReference)resource, -1); 23173 } else if (resource instanceof Encounter) { 23174 composeEncounter(parent, null, "Encounter", (Encounter)resource, -1); 23175 } else if (resource instanceof Endpoint) { 23176 composeEndpoint(parent, null, "Endpoint", (Endpoint)resource, -1); 23177 } else if (resource instanceof EnrollmentRequest) { 23178 composeEnrollmentRequest(parent, null, "EnrollmentRequest", (EnrollmentRequest)resource, -1); 23179 } else if (resource instanceof EnrollmentResponse) { 23180 composeEnrollmentResponse(parent, null, "EnrollmentResponse", (EnrollmentResponse)resource, -1); 23181 } else if (resource instanceof EpisodeOfCare) { 23182 composeEpisodeOfCare(parent, null, "EpisodeOfCare", (EpisodeOfCare)resource, -1); 23183 } else if (resource instanceof EventDefinition) { 23184 composeEventDefinition(parent, null, "EventDefinition", (EventDefinition)resource, -1); 23185 } else if (resource instanceof Evidence) { 23186 composeEvidence(parent, null, "Evidence", (Evidence)resource, -1); 23187 } else if (resource instanceof EvidenceVariable) { 23188 composeEvidenceVariable(parent, null, "EvidenceVariable", (EvidenceVariable)resource, -1); 23189 } else if (resource instanceof ExampleScenario) { 23190 composeExampleScenario(parent, null, "ExampleScenario", (ExampleScenario)resource, -1); 23191 } else if (resource instanceof ExplanationOfBenefit) { 23192 composeExplanationOfBenefit(parent, null, "ExplanationOfBenefit", (ExplanationOfBenefit)resource, -1); 23193 } else if (resource instanceof FamilyMemberHistory) { 23194 composeFamilyMemberHistory(parent, null, "FamilyMemberHistory", (FamilyMemberHistory)resource, -1); 23195 } else if (resource instanceof Flag) { 23196 composeFlag(parent, null, "Flag", (Flag)resource, -1); 23197 } else if (resource instanceof Goal) { 23198 composeGoal(parent, null, "Goal", (Goal)resource, -1); 23199 } else if (resource instanceof GraphDefinition) { 23200 composeGraphDefinition(parent, null, "GraphDefinition", (GraphDefinition)resource, -1); 23201 } else if (resource instanceof Group) { 23202 composeGroup(parent, null, "Group", (Group)resource, -1); 23203 } else if (resource instanceof GuidanceResponse) { 23204 composeGuidanceResponse(parent, null, "GuidanceResponse", (GuidanceResponse)resource, -1); 23205 } else if (resource instanceof HealthcareService) { 23206 composeHealthcareService(parent, null, "HealthcareService", (HealthcareService)resource, -1); 23207 } else if (resource instanceof ImagingStudy) { 23208 composeImagingStudy(parent, null, "ImagingStudy", (ImagingStudy)resource, -1); 23209 } else if (resource instanceof Immunization) { 23210 composeImmunization(parent, null, "Immunization", (Immunization)resource, -1); 23211 } else if (resource instanceof ImmunizationEvaluation) { 23212 composeImmunizationEvaluation(parent, null, "ImmunizationEvaluation", (ImmunizationEvaluation)resource, -1); 23213 } else if (resource instanceof ImmunizationRecommendation) { 23214 composeImmunizationRecommendation(parent, null, "ImmunizationRecommendation", (ImmunizationRecommendation)resource, -1); 23215 } else if (resource instanceof ImplementationGuide) { 23216 composeImplementationGuide(parent, null, "ImplementationGuide", (ImplementationGuide)resource, -1); 23217 } else if (resource instanceof Ingredient) { 23218 composeIngredient(parent, null, "Ingredient", (Ingredient)resource, -1); 23219 } else if (resource instanceof InsurancePlan) { 23220 composeInsurancePlan(parent, null, "InsurancePlan", (InsurancePlan)resource, -1); 23221 } else if (resource instanceof Invoice) { 23222 composeInvoice(parent, null, "Invoice", (Invoice)resource, -1); 23223 } else if (resource instanceof Library) { 23224 composeLibrary(parent, null, "Library", (Library)resource, -1); 23225 } else if (resource instanceof Linkage) { 23226 composeLinkage(parent, null, "Linkage", (Linkage)resource, -1); 23227 } else if (resource instanceof ListResource) { 23228 composeListResource(parent, null, "List", (ListResource)resource, -1); 23229 } else if (resource instanceof Location) { 23230 composeLocation(parent, null, "Location", (Location)resource, -1); 23231 } else if (resource instanceof ManufacturedItemDefinition) { 23232 composeManufacturedItemDefinition(parent, null, "ManufacturedItemDefinition", (ManufacturedItemDefinition)resource, -1); 23233 } else if (resource instanceof Measure) { 23234 composeMeasure(parent, null, "Measure", (Measure)resource, -1); 23235 } else if (resource instanceof MeasureReport) { 23236 composeMeasureReport(parent, null, "MeasureReport", (MeasureReport)resource, -1); 23237 } else if (resource instanceof Medication) { 23238 composeMedication(parent, null, "Medication", (Medication)resource, -1); 23239 } else if (resource instanceof MedicationAdministration) { 23240 composeMedicationAdministration(parent, null, "MedicationAdministration", (MedicationAdministration)resource, -1); 23241 } else if (resource instanceof MedicationDispense) { 23242 composeMedicationDispense(parent, null, "MedicationDispense", (MedicationDispense)resource, -1); 23243 } else if (resource instanceof MedicationKnowledge) { 23244 composeMedicationKnowledge(parent, null, "MedicationKnowledge", (MedicationKnowledge)resource, -1); 23245 } else if (resource instanceof MedicationRequest) { 23246 composeMedicationRequest(parent, null, "MedicationRequest", (MedicationRequest)resource, -1); 23247 } else if (resource instanceof MedicationUsage) { 23248 composeMedicationUsage(parent, null, "MedicationUsage", (MedicationUsage)resource, -1); 23249 } else if (resource instanceof MedicinalProductDefinition) { 23250 composeMedicinalProductDefinition(parent, null, "MedicinalProductDefinition", (MedicinalProductDefinition)resource, -1); 23251 } else if (resource instanceof MessageDefinition) { 23252 composeMessageDefinition(parent, null, "MessageDefinition", (MessageDefinition)resource, -1); 23253 } else if (resource instanceof MessageHeader) { 23254 composeMessageHeader(parent, null, "MessageHeader", (MessageHeader)resource, -1); 23255 } else if (resource instanceof MolecularSequence) { 23256 composeMolecularSequence(parent, null, "MolecularSequence", (MolecularSequence)resource, -1); 23257 } else if (resource instanceof NamingSystem) { 23258 composeNamingSystem(parent, null, "NamingSystem", (NamingSystem)resource, -1); 23259 } else if (resource instanceof NutritionIntake) { 23260 composeNutritionIntake(parent, null, "NutritionIntake", (NutritionIntake)resource, -1); 23261 } else if (resource instanceof NutritionOrder) { 23262 composeNutritionOrder(parent, null, "NutritionOrder", (NutritionOrder)resource, -1); 23263 } else if (resource instanceof Observation) { 23264 composeObservation(parent, null, "Observation", (Observation)resource, -1); 23265 } else if (resource instanceof ObservationDefinition) { 23266 composeObservationDefinition(parent, null, "ObservationDefinition", (ObservationDefinition)resource, -1); 23267 } else if (resource instanceof OperationDefinition) { 23268 composeOperationDefinition(parent, null, "OperationDefinition", (OperationDefinition)resource, -1); 23269 } else if (resource instanceof OperationOutcome) { 23270 composeOperationOutcome(parent, null, "OperationOutcome", (OperationOutcome)resource, -1); 23271 } else if (resource instanceof Organization) { 23272 composeOrganization(parent, null, "Organization", (Organization)resource, -1); 23273 } else if (resource instanceof OrganizationAffiliation) { 23274 composeOrganizationAffiliation(parent, null, "OrganizationAffiliation", (OrganizationAffiliation)resource, -1); 23275 } else if (resource instanceof PackagedProductDefinition) { 23276 composePackagedProductDefinition(parent, null, "PackagedProductDefinition", (PackagedProductDefinition)resource, -1); 23277 } else if (resource instanceof Parameters) { 23278 composeParameters(parent, null, "Parameters", (Parameters)resource, -1); 23279 } else if (resource instanceof Patient) { 23280 composePatient(parent, null, "Patient", (Patient)resource, -1); 23281 } else if (resource instanceof PaymentNotice) { 23282 composePaymentNotice(parent, null, "PaymentNotice", (PaymentNotice)resource, -1); 23283 } else if (resource instanceof PaymentReconciliation) { 23284 composePaymentReconciliation(parent, null, "PaymentReconciliation", (PaymentReconciliation)resource, -1); 23285 } else if (resource instanceof Person) { 23286 composePerson(parent, null, "Person", (Person)resource, -1); 23287 } else if (resource instanceof PlanDefinition) { 23288 composePlanDefinition(parent, null, "PlanDefinition", (PlanDefinition)resource, -1); 23289 } else if (resource instanceof Practitioner) { 23290 composePractitioner(parent, null, "Practitioner", (Practitioner)resource, -1); 23291 } else if (resource instanceof PractitionerRole) { 23292 composePractitionerRole(parent, null, "PractitionerRole", (PractitionerRole)resource, -1); 23293 } else if (resource instanceof Procedure) { 23294 composeProcedure(parent, null, "Procedure", (Procedure)resource, -1); 23295 } else if (resource instanceof Provenance) { 23296 composeProvenance(parent, null, "Provenance", (Provenance)resource, -1); 23297 } else if (resource instanceof Questionnaire) { 23298 composeQuestionnaire(parent, null, "Questionnaire", (Questionnaire)resource, -1); 23299 } else if (resource instanceof QuestionnaireResponse) { 23300 composeQuestionnaireResponse(parent, null, "QuestionnaireResponse", (QuestionnaireResponse)resource, -1); 23301 } else if (resource instanceof RegulatedAuthorization) { 23302 composeRegulatedAuthorization(parent, null, "RegulatedAuthorization", (RegulatedAuthorization)resource, -1); 23303 } else if (resource instanceof RelatedPerson) { 23304 composeRelatedPerson(parent, null, "RelatedPerson", (RelatedPerson)resource, -1); 23305 } else if (resource instanceof RequestGroup) { 23306 composeRequestGroup(parent, null, "RequestGroup", (RequestGroup)resource, -1); 23307 } else if (resource instanceof ResearchStudy) { 23308 composeResearchStudy(parent, null, "ResearchStudy", (ResearchStudy)resource, -1); 23309 } else if (resource instanceof ResearchSubject) { 23310 composeResearchSubject(parent, null, "ResearchSubject", (ResearchSubject)resource, -1); 23311 } else if (resource instanceof RiskAssessment) { 23312 composeRiskAssessment(parent, null, "RiskAssessment", (RiskAssessment)resource, -1); 23313 } else if (resource instanceof Schedule) { 23314 composeSchedule(parent, null, "Schedule", (Schedule)resource, -1); 23315 } else if (resource instanceof SearchParameter) { 23316 composeSearchParameter(parent, null, "SearchParameter", (SearchParameter)resource, -1); 23317 } else if (resource instanceof ServiceRequest) { 23318 composeServiceRequest(parent, null, "ServiceRequest", (ServiceRequest)resource, -1); 23319 } else if (resource instanceof Slot) { 23320 composeSlot(parent, null, "Slot", (Slot)resource, -1); 23321 } else if (resource instanceof Specimen) { 23322 composeSpecimen(parent, null, "Specimen", (Specimen)resource, -1); 23323 } else if (resource instanceof SpecimenDefinition) { 23324 composeSpecimenDefinition(parent, null, "SpecimenDefinition", (SpecimenDefinition)resource, -1); 23325 } else if (resource instanceof StructureDefinition) { 23326 composeStructureDefinition(parent, null, "StructureDefinition", (StructureDefinition)resource, -1); 23327 } else if (resource instanceof StructureMap) { 23328 composeStructureMap(parent, null, "StructureMap", (StructureMap)resource, -1); 23329 } else if (resource instanceof Subscription) { 23330 composeSubscription(parent, null, "Subscription", (Subscription)resource, -1); 23331 } else if (resource instanceof Substance) { 23332 composeSubstance(parent, null, "Substance", (Substance)resource, -1); 23333 } else if (resource instanceof SubstanceDefinition) { 23334 composeSubstanceDefinition(parent, null, "SubstanceDefinition", (SubstanceDefinition)resource, -1); 23335 } else if (resource instanceof SubstanceNucleicAcid) { 23336 composeSubstanceNucleicAcid(parent, null, "SubstanceNucleicAcid", (SubstanceNucleicAcid)resource, -1); 23337 } else if (resource instanceof SubstancePolymer) { 23338 composeSubstancePolymer(parent, null, "SubstancePolymer", (SubstancePolymer)resource, -1); 23339 } else if (resource instanceof SubstanceProtein) { 23340 composeSubstanceProtein(parent, null, "SubstanceProtein", (SubstanceProtein)resource, -1); 23341 } else if (resource instanceof SubstanceReferenceInformation) { 23342 composeSubstanceReferenceInformation(parent, null, "SubstanceReferenceInformation", (SubstanceReferenceInformation)resource, -1); 23343 } else if (resource instanceof SubstanceSourceMaterial) { 23344 composeSubstanceSourceMaterial(parent, null, "SubstanceSourceMaterial", (SubstanceSourceMaterial)resource, -1); 23345 } else if (resource instanceof SupplyDelivery) { 23346 composeSupplyDelivery(parent, null, "SupplyDelivery", (SupplyDelivery)resource, -1); 23347 } else if (resource instanceof SupplyRequest) { 23348 composeSupplyRequest(parent, null, "SupplyRequest", (SupplyRequest)resource, -1); 23349 } else if (resource instanceof Task) { 23350 composeTask(parent, null, "Task", (Task)resource, -1); 23351 } else if (resource instanceof TerminologyCapabilities) { 23352 composeTerminologyCapabilities(parent, null, "TerminologyCapabilities", (TerminologyCapabilities)resource, -1); 23353 } else if (resource instanceof TestReport) { 23354 composeTestReport(parent, null, "TestReport", (TestReport)resource, -1); 23355 } else if (resource instanceof TestScript) { 23356 composeTestScript(parent, null, "TestScript", (TestScript)resource, -1); 23357 } else if (resource instanceof Topic) { 23358 composeTopic(parent, null, "Topic", (Topic)resource, -1); 23359 } else if (resource instanceof ValueSet) { 23360 composeValueSet(parent, null, "ValueSet", (ValueSet)resource, -1); 23361 } else if (resource instanceof VerificationResult) { 23362 composeVerificationResult(parent, null, "VerificationResult", (VerificationResult)resource, -1); 23363 } else if (resource instanceof VisionPrescription) { 23364 composeVisionPrescription(parent, null, "VisionPrescription", (VisionPrescription)resource, -1); 23365 23366 } else { 23367 throw new Error("Unhandled resource type "+resource.getClass().getName()); 23368 } 23369 } 23370 23371 protected void composeType(Complex parent, String parentType, String name, DataType value, int index) { 23372 if (parent == null) { 23373 throw new Error("parent == null"); 23374 } else if (parentType == null) { 23375 throw new Error("parentType == null"); 23376 } else if (name == null) { 23377 throw new Error("name == null"); 23378 } else if (value == null) { 23379 throw new Error("value == null"); 23380 } else if (value instanceof DateType) { 23381 composeDate(parent, parentType, name, (DateType)value, index); 23382 } else if (value instanceof DateTimeType) { 23383 composeDateTime(parent, parentType, name, (DateTimeType)value, index); 23384 } else if (value instanceof CodeType) { 23385 composeCode(parent, parentType, name, (CodeType)value, index); 23386 } else if (value instanceof StringType) { 23387 composeString(parent, parentType, name, (StringType)value, index); 23388 } else if (value instanceof IntegerType) { 23389 composeInteger(parent, parentType, name, (IntegerType)value, index); 23390 } else if (value instanceof Integer64Type) { 23391 composeInteger64(parent, parentType, name, (Integer64Type)value, index); 23392 } else if (value instanceof OidType) { 23393 composeOid(parent, parentType, name, (OidType)value, index); 23394 } else if (value instanceof CanonicalType) { 23395 composeCanonical(parent, parentType, name, (CanonicalType)value, index); 23396 } else if (value instanceof UriType) { 23397 composeUri(parent, parentType, name, (UriType)value, index); 23398 } else if (value instanceof UuidType) { 23399 composeUuid(parent, parentType, name, (UuidType)value, index); 23400 } else if (value instanceof UrlType) { 23401 composeUrl(parent, parentType, name, (UrlType)value, index); 23402 } else if (value instanceof InstantType) { 23403 composeInstant(parent, parentType, name, (InstantType)value, index); 23404 } else if (value instanceof BooleanType) { 23405 composeBoolean(parent, parentType, name, (BooleanType)value, index); 23406 } else if (value instanceof Base64BinaryType) { 23407 composeBase64Binary(parent, parentType, name, (Base64BinaryType)value, index); 23408 } else if (value instanceof UnsignedIntType) { 23409 composeUnsignedInt(parent, parentType, name, (UnsignedIntType)value, index); 23410 } else if (value instanceof MarkdownType) { 23411 composeMarkdown(parent, parentType, name, (MarkdownType)value, index); 23412 } else if (value instanceof TimeType) { 23413 composeTime(parent, parentType, name, (TimeType)value, index); 23414 } else if (value instanceof IdType) { 23415 composeId(parent, parentType, name, (IdType)value, index); 23416 } else if (value instanceof PositiveIntType) { 23417 composePositiveInt(parent, parentType, name, (PositiveIntType)value, index); 23418 } else if (value instanceof DecimalType) { 23419 composeDecimal(parent, parentType, name, (DecimalType)value, index); 23420 } else if (value instanceof Address) { 23421 composeAddress(parent, parentType, name, (Address)value, index); 23422 } else if (value instanceof Age) { 23423 composeAge(parent, parentType, name, (Age)value, index); 23424 } else if (value instanceof Annotation) { 23425 composeAnnotation(parent, parentType, name, (Annotation)value, index); 23426 } else if (value instanceof Attachment) { 23427 composeAttachment(parent, parentType, name, (Attachment)value, index); 23428 } else if (value instanceof CodeableConcept) { 23429 composeCodeableConcept(parent, parentType, name, (CodeableConcept)value, index); 23430 } else if (value instanceof CodeableReference) { 23431 composeCodeableReference(parent, parentType, name, (CodeableReference)value, index); 23432 } else if (value instanceof Coding) { 23433 composeCoding(parent, parentType, name, (Coding)value, index); 23434 } else if (value instanceof ContactDetail) { 23435 composeContactDetail(parent, parentType, name, (ContactDetail)value, index); 23436 } else if (value instanceof ContactPoint) { 23437 composeContactPoint(parent, parentType, name, (ContactPoint)value, index); 23438 } else if (value instanceof Contributor) { 23439 composeContributor(parent, parentType, name, (Contributor)value, index); 23440 } else if (value instanceof Count) { 23441 composeCount(parent, parentType, name, (Count)value, index); 23442 } else if (value instanceof DataRequirement) { 23443 composeDataRequirement(parent, parentType, name, (DataRequirement)value, index); 23444 } else if (value instanceof Distance) { 23445 composeDistance(parent, parentType, name, (Distance)value, index); 23446 } else if (value instanceof Dosage) { 23447 composeDosage(parent, parentType, name, (Dosage)value, index); 23448 } else if (value instanceof Duration) { 23449 composeDuration(parent, parentType, name, (Duration)value, index); 23450 } else if (value instanceof ElementDefinition) { 23451 composeElementDefinition(parent, parentType, name, (ElementDefinition)value, index); 23452 } else if (value instanceof Expression) { 23453 composeExpression(parent, parentType, name, (Expression)value, index); 23454 } else if (value instanceof Extension) { 23455 composeExtension(parent, parentType, name, (Extension)value, index); 23456 } else if (value instanceof HumanName) { 23457 composeHumanName(parent, parentType, name, (HumanName)value, index); 23458 } else if (value instanceof Identifier) { 23459 composeIdentifier(parent, parentType, name, (Identifier)value, index); 23460 } else if (value instanceof MarketingStatus) { 23461 composeMarketingStatus(parent, parentType, name, (MarketingStatus)value, index); 23462 } else if (value instanceof Meta) { 23463 composeMeta(parent, parentType, name, (Meta)value, index); 23464 } else if (value instanceof Money) { 23465 composeMoney(parent, parentType, name, (Money)value, index); 23466 } else if (value instanceof Narrative) { 23467 composeNarrative(parent, parentType, name, (Narrative)value, index); 23468 } else if (value instanceof OrderedDistribution) { 23469 composeOrderedDistribution(parent, parentType, name, (OrderedDistribution)value, index); 23470 } else if (value instanceof ParameterDefinition) { 23471 composeParameterDefinition(parent, parentType, name, (ParameterDefinition)value, index); 23472 } else if (value instanceof Period) { 23473 composePeriod(parent, parentType, name, (Period)value, index); 23474 } else if (value instanceof Population) { 23475 composePopulation(parent, parentType, name, (Population)value, index); 23476 } else if (value instanceof ProdCharacteristic) { 23477 composeProdCharacteristic(parent, parentType, name, (ProdCharacteristic)value, index); 23478 } else if (value instanceof ProductShelfLife) { 23479 composeProductShelfLife(parent, parentType, name, (ProductShelfLife)value, index); 23480 } else if (value instanceof Quantity) { 23481 composeQuantity(parent, parentType, name, (Quantity)value, index); 23482 } else if (value instanceof Range) { 23483 composeRange(parent, parentType, name, (Range)value, index); 23484 } else if (value instanceof Ratio) { 23485 composeRatio(parent, parentType, name, (Ratio)value, index); 23486 } else if (value instanceof Reference) { 23487 composeReference(parent, parentType, name, (Reference)value, index); 23488 } else if (value instanceof RelatedArtifact) { 23489 composeRelatedArtifact(parent, parentType, name, (RelatedArtifact)value, index); 23490 } else if (value instanceof SampledData) { 23491 composeSampledData(parent, parentType, name, (SampledData)value, index); 23492 } else if (value instanceof Signature) { 23493 composeSignature(parent, parentType, name, (Signature)value, index); 23494 } else if (value instanceof Statistic) { 23495 composeStatistic(parent, parentType, name, (Statistic)value, index); 23496 } else if (value instanceof SubstanceAmount) { 23497 composeSubstanceAmount(parent, parentType, name, (SubstanceAmount)value, index); 23498 } else if (value instanceof Timing) { 23499 composeTiming(parent, parentType, name, (Timing)value, index); 23500 } else if (value instanceof TriggerDefinition) { 23501 composeTriggerDefinition(parent, parentType, name, (TriggerDefinition)value, index); 23502 } else if (value instanceof UsageContext) { 23503 composeUsageContext(parent, parentType, name, (UsageContext)value, index); 23504 23505 } else { 23506 throw new Error("Unhandled type"); 23507 } 23508 } 23509 23510} 23511