001package org.hl7.fhir.r5.formats; 002 003 004// generated 005 006/* 007 Copyright (c) 2011+, HL7, Inc. 008 All rights reserved. 009 010 Redistribution and use in source and binary forms, with or without modification, \ 011 are permitted provided that the following conditions are met: 012 013 * Redistributions of source code must retain the above copyright notice, this \ 014 list of conditions and the following disclaimer. 015 * Redistributions in binary form must reproduce the above copyright notice, \ 016 this list of conditions and the following disclaimer in the documentation \ 017 and/or other materials provided with the distribution. 018 * Neither the name of HL7 nor the names of its contributors may be used to 019 endorse or promote products derived from this software without specific 020 prior written permission. 021 022 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \ 023 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \ 024 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \ 025 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \ 026 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \ 027 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \ 028 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \ 029 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \ 030 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \ 031 POSSIBILITY OF SUCH DAMAGE. 032 */ 033 034// Generated on Thu, Mar 23, 2023 19:59+1100 for FHIR v5.0.0 035 036 037 038import org.hl7.fhir.r5.model.*; 039import org.hl7.fhir.r5.model.StringType; 040import org.hl7.fhir.utilities.Utilities; 041import org.hl7.fhir.exceptions.FHIRFormatError; 042import org.hl7.fhir.exceptions.FHIRException; 043import org.hl7.fhir.utilities.turtle.Turtle.*; 044import java.io.IOException; 045 046public class RdfParser extends RdfParserBase { 047 048 public RdfParser() { 049 super(); 050 } 051 052 public RdfParser(boolean allowUnknownContent) { 053 super(); 054 setAllowUnknownContent(allowUnknownContent); 055 } 056 057 private void composeEnum(Complex parent, String parentType, String name, Enumeration<? extends Enum> value, int index) { 058 if (value == null) 059 return; 060 Complex t = parent.predicate("fhir:"+name, index > -1); 061 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 062 composeElement(t, parentType, name, value, index); 063 decorateCode(t, value); 064 } 065 066 067 protected void composeDate(Complex parent, String parentType, String name, DateType value, int index) { 068 if (value == null) 069 return; 070 Complex t = parent.predicate("fhir:"+name, index > -1); 071 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 072 composeElement(t, parentType, name, value, index); 073 } 074 075 protected void composeDateTime(Complex parent, String parentType, String name, DateTimeType value, int index) { 076 if (value == null) 077 return; 078 Complex t = parent.predicate("fhir:"+name, index > -1); 079 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 080 composeElement(t, parentType, name, value, index); 081 } 082 083 protected void composeCode(Complex parent, String parentType, String name, CodeType value, int index) { 084 if (value == null) 085 return; 086 Complex t = parent.predicate("fhir:"+name, index > -1); 087 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 088 composeElement(t, parentType, name, value, index); 089 decorateCode(t, value); 090 } 091 092 protected void composeString(Complex parent, String parentType, String name, StringType value, int index) { 093 if (value == null) 094 return; 095 Complex t = parent.predicate("fhir:"+name, index > -1); 096 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 097 composeElement(t, parentType, name, value, index); 098 } 099 100 protected void composeInteger(Complex parent, String parentType, String name, IntegerType value, int index) { 101 if (value == null) 102 return; 103 Complex t = parent.predicate("fhir:"+name, index > -1); 104 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 105 composeElement(t, parentType, name, value, index); 106 } 107 108 protected void composeInteger64(Complex parent, String parentType, String name, Integer64Type value, int index) { 109 if (value == null) 110 return; 111 Complex t = parent.predicate("fhir:"+name, index > -1); 112 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 113 composeElement(t, parentType, name, value, index); 114 } 115 116 protected void composeOid(Complex parent, String parentType, String name, OidType value, int index) { 117 if (value == null) 118 return; 119 Complex t = parent.predicate("fhir:"+name, index > -1); 120 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 121 composeElement(t, parentType, name, value, index); 122 } 123 124 protected void composeCanonical(Complex parent, String parentType, String name, CanonicalType value, int index) { 125 if (value == null) 126 return; 127 Complex t = parent.predicate("fhir:"+name, index > -1); 128 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 129 composeElement(t, parentType, name, value, index); 130 } 131 132 protected void composeUri(Complex parent, String parentType, String name, UriType value, int index) { 133 if (value == null) 134 return; 135 Complex t = parent.predicate("fhir:"+name, index > -1); 136 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 137 composeElement(t, parentType, name, value, index); 138 } 139 140 protected void composeUuid(Complex parent, String parentType, String name, UuidType value, int index) { 141 if (value == null) 142 return; 143 Complex t = parent.predicate("fhir:"+name, index > -1); 144 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 145 composeElement(t, parentType, name, value, index); 146 } 147 148 protected void composeUrl(Complex parent, String parentType, String name, UrlType value, int index) { 149 if (value == null) 150 return; 151 Complex t = parent.predicate("fhir:"+name, index > -1); 152 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 153 composeElement(t, parentType, name, value, index); 154 } 155 156 protected void composeInstant(Complex parent, String parentType, String name, InstantType value, int index) { 157 if (value == null) 158 return; 159 Complex t = parent.predicate("fhir:"+name, index > -1); 160 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 161 composeElement(t, parentType, name, value, index); 162 } 163 164 protected void composeBoolean(Complex parent, String parentType, String name, BooleanType value, int index) { 165 if (value == null) 166 return; 167 Complex t = parent.predicate("fhir:"+name, index > -1); 168 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 169 composeElement(t, parentType, name, value, index); 170 } 171 172 protected void composeBase64Binary(Complex parent, String parentType, String name, Base64BinaryType value, int index) { 173 if (value == null) 174 return; 175 Complex t = parent.predicate("fhir:"+name, index > -1); 176 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 177 composeElement(t, parentType, name, value, index); 178 } 179 180 protected void composeUnsignedInt(Complex parent, String parentType, String name, UnsignedIntType value, int index) { 181 if (value == null) 182 return; 183 Complex t = parent.predicate("fhir:"+name, index > -1); 184 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 185 composeElement(t, parentType, name, value, index); 186 } 187 188 protected void composeMarkdown(Complex parent, String parentType, String name, MarkdownType value, int index) { 189 if (value == null) 190 return; 191 Complex t = parent.predicate("fhir:"+name, index > -1); 192 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 193 composeElement(t, parentType, name, value, index); 194 } 195 196 protected void composeTime(Complex parent, String parentType, String name, TimeType value, int index) { 197 if (value == null) 198 return; 199 Complex t = parent.predicate("fhir:"+name, index > -1); 200 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 201 composeElement(t, parentType, name, value, index); 202 } 203 204 protected void composeId(Complex parent, String parentType, String name, IdType value, int index) { 205 if (value == null) 206 return; 207 Complex t = parent.predicate("fhir:"+name, index > -1); 208 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 209 composeElement(t, parentType, name, value, index); 210 } 211 212 protected void composePositiveInt(Complex parent, String parentType, String name, PositiveIntType value, int index) { 213 if (value == null) 214 return; 215 Complex t = parent.predicate("fhir:"+name, index > -1); 216 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 217 composeElement(t, parentType, name, value, index); 218 } 219 220 protected void composeDecimal(Complex parent, String parentType, String name, DecimalType value, int index) { 221 if (value == null) 222 return; 223 Complex t = parent.predicate("fhir:"+name, index > -1); 224 t.predicate("fhir:v", ttlLiteral(value.asStringValue()), false); 225 composeElement(t, parentType, name, value, index); 226 } 227 228 protected void composeBackboneElement(Complex t, String parentType, String name, BackboneElement element, int index) { 229 composeElement(t, parentType, name, element, index); 230 for (int i = 0; i < element.getModifierExtension().size(); i++) { 231 composeExtension(t, "BackboneElement", "modifierExtension", element.getModifierExtension().get(i), i); 232 } 233 } 234 235 protected void composeBackboneType(Complex t, String parentType, String name, BackboneType element, int index) { 236 composeDataType(t, parentType, name, element, index); 237 for (int i = 0; i < element.getModifierExtension().size(); i++) { 238 composeExtension(t, "BackboneType", "modifierExtension", element.getModifierExtension().get(i), i); 239 } 240 } 241 242 protected void composeDataType(Complex t, String parentType, String name, DataType element, int index) { 243 composeElement(t, parentType, name, element, index); 244 } 245 246 protected void composeElement(Complex t, String parentType, String name, Element element, int index) { 247 composeBase(t, parentType, name, element, index); 248 if (element.hasIdElement()) { 249 composeString(t, "Element", "id", element.getIdElement(), -1); 250 } 251 for (int i = 0; i < element.getExtension().size(); i++) { 252 composeExtension(t, "Element", "extension", element.getExtension().get(i), i); 253 } 254 } 255 256 protected void composeAddress(Complex parent, String parentType, String name, Address element, int index) { 257 if (element == null) 258 return; 259 Complex t; 260 if (Utilities.noString(parentType)) 261 t = parent; 262 else { 263 t = parent.predicate("fhir:"+name,index > -1); 264 } 265 composeDataType(t, "Address", name, element, index); 266 if (element.hasUseElement()) { 267 composeEnum(t, "Address", "use", element.getUseElement(), -1); 268 } 269 if (element.hasTypeElement()) { 270 composeEnum(t, "Address", "type", element.getTypeElement(), -1); 271 } 272 if (element.hasTextElement()) { 273 composeString(t, "Address", "text", element.getTextElement(), -1); 274 } 275 for (int i = 0; i < element.getLine().size(); i++) { 276 composeString(t, "Address", "line", element.getLine().get(i), i); 277 } 278 if (element.hasCityElement()) { 279 composeString(t, "Address", "city", element.getCityElement(), -1); 280 } 281 if (element.hasDistrictElement()) { 282 composeString(t, "Address", "district", element.getDistrictElement(), -1); 283 } 284 if (element.hasStateElement()) { 285 composeString(t, "Address", "state", element.getStateElement(), -1); 286 } 287 if (element.hasPostalCodeElement()) { 288 composeString(t, "Address", "postalCode", element.getPostalCodeElement(), -1); 289 } 290 if (element.hasCountryElement()) { 291 composeString(t, "Address", "country", element.getCountryElement(), -1); 292 } 293 if (element.hasPeriod()) { 294 composePeriod(t, "Address", "period", element.getPeriod(), -1); 295 } 296 } 297 298 protected void composeAge(Complex parent, String parentType, String name, Age element, int index) { 299 if (element == null) 300 return; 301 Complex t; 302 if (Utilities.noString(parentType)) 303 t = parent; 304 else { 305 t = parent.predicate("fhir:"+name,index > -1); 306 } 307 composeQuantity(t, "Age", name, element, index); 308 } 309 310 protected void composeAnnotation(Complex parent, String parentType, String name, Annotation element, int index) { 311 if (element == null) 312 return; 313 Complex t; 314 if (Utilities.noString(parentType)) 315 t = parent; 316 else { 317 t = parent.predicate("fhir:"+name,index > -1); 318 } 319 composeDataType(t, "Annotation", name, element, index); 320 if (element.hasAuthor()) { 321 composeType(t, "Annotation", "author", element.getAuthor(), -1); 322 } 323 if (element.hasTimeElement()) { 324 composeDateTime(t, "Annotation", "time", element.getTimeElement(), -1); 325 } 326 if (element.hasTextElement()) { 327 composeMarkdown(t, "Annotation", "text", element.getTextElement(), -1); 328 } 329 } 330 331 protected void composeAttachment(Complex parent, String parentType, String name, Attachment element, int index) { 332 if (element == null) 333 return; 334 Complex t; 335 if (Utilities.noString(parentType)) 336 t = parent; 337 else { 338 t = parent.predicate("fhir:"+name,index > -1); 339 } 340 composeDataType(t, "Attachment", name, element, index); 341 if (element.hasContentTypeElement()) { 342 composeCode(t, "Attachment", "contentType", element.getContentTypeElement(), -1); 343 } 344 if (element.hasLanguageElement()) { 345 composeCode(t, "Attachment", "language", element.getLanguageElement(), -1); 346 } 347 if (element.hasDataElement()) { 348 composeBase64Binary(t, "Attachment", "data", element.getDataElement(), -1); 349 } 350 if (element.hasUrlElement()) { 351 composeUrl(t, "Attachment", "url", element.getUrlElement(), -1); 352 } 353 if (element.hasSizeElement()) { 354 composeInteger64(t, "Attachment", "size", element.getSizeElement(), -1); 355 } 356 if (element.hasHashElement()) { 357 composeBase64Binary(t, "Attachment", "hash", element.getHashElement(), -1); 358 } 359 if (element.hasTitleElement()) { 360 composeString(t, "Attachment", "title", element.getTitleElement(), -1); 361 } 362 if (element.hasCreationElement()) { 363 composeDateTime(t, "Attachment", "creation", element.getCreationElement(), -1); 364 } 365 if (element.hasHeightElement()) { 366 composePositiveInt(t, "Attachment", "height", element.getHeightElement(), -1); 367 } 368 if (element.hasWidthElement()) { 369 composePositiveInt(t, "Attachment", "width", element.getWidthElement(), -1); 370 } 371 if (element.hasFramesElement()) { 372 composePositiveInt(t, "Attachment", "frames", element.getFramesElement(), -1); 373 } 374 if (element.hasDurationElement()) { 375 composeDecimal(t, "Attachment", "duration", element.getDurationElement(), -1); 376 } 377 if (element.hasPagesElement()) { 378 composePositiveInt(t, "Attachment", "pages", element.getPagesElement(), -1); 379 } 380 } 381 382 protected void composeAvailability(Complex parent, String parentType, String name, Availability element, int index) { 383 if (element == null) 384 return; 385 Complex t; 386 if (Utilities.noString(parentType)) 387 t = parent; 388 else { 389 t = parent.predicate("fhir:"+name,index > -1); 390 } 391 composeDataType(t, "Availability", name, element, index); 392 for (int i = 0; i < element.getAvailableTime().size(); i++) { 393 composeAvailabilityAvailableTimeComponent(t, "Availability", "availableTime", element.getAvailableTime().get(i), i); 394 } 395 for (int i = 0; i < element.getNotAvailableTime().size(); i++) { 396 composeAvailabilityNotAvailableTimeComponent(t, "Availability", "notAvailableTime", element.getNotAvailableTime().get(i), i); 397 } 398 } 399 400 protected void composeAvailabilityAvailableTimeComponent(Complex parent, String parentType, String name, Availability.AvailabilityAvailableTimeComponent element, int index) { 401 if (element == null) 402 return; 403 Complex t; 404 if (Utilities.noString(parentType)) 405 t = parent; 406 else { 407 t = parent.predicate("fhir:"+name,index > -1); 408 } 409 composeElement(t, "availableTime", name, element, index); 410 for (int i = 0; i < element.getDaysOfWeek().size(); i++) { 411 composeEnum(t, "AvailabilityAvailableTimeComponent", "daysOfWeek", element.getDaysOfWeek().get(i), i); 412 } 413 if (element.hasAllDayElement()) { 414 composeBoolean(t, "AvailabilityAvailableTimeComponent", "allDay", element.getAllDayElement(), -1); 415 } 416 if (element.hasAvailableStartTimeElement()) { 417 composeTime(t, "AvailabilityAvailableTimeComponent", "availableStartTime", element.getAvailableStartTimeElement(), -1); 418 } 419 if (element.hasAvailableEndTimeElement()) { 420 composeTime(t, "AvailabilityAvailableTimeComponent", "availableEndTime", element.getAvailableEndTimeElement(), -1); 421 } 422 } 423 424 protected void composeAvailabilityNotAvailableTimeComponent(Complex parent, String parentType, String name, Availability.AvailabilityNotAvailableTimeComponent element, int index) { 425 if (element == null) 426 return; 427 Complex t; 428 if (Utilities.noString(parentType)) 429 t = parent; 430 else { 431 t = parent.predicate("fhir:"+name,index > -1); 432 } 433 composeElement(t, "notAvailableTime", name, element, index); 434 if (element.hasDescriptionElement()) { 435 composeString(t, "AvailabilityNotAvailableTimeComponent", "description", element.getDescriptionElement(), -1); 436 } 437 if (element.hasDuring()) { 438 composePeriod(t, "AvailabilityNotAvailableTimeComponent", "during", element.getDuring(), -1); 439 } 440 } 441 442 protected void composeCodeableConcept(Complex parent, String parentType, String name, CodeableConcept element, int index) { 443 if (element == null) 444 return; 445 Complex t; 446 if (Utilities.noString(parentType)) 447 t = parent; 448 else { 449 t = parent.predicate("fhir:"+name,index > -1); 450 } 451 composeDataType(t, "CodeableConcept", name, element, index); 452 decorateCodeableConcept(t, element); 453 for (int i = 0; i < element.getCoding().size(); i++) { 454 composeCoding(t, "CodeableConcept", "coding", element.getCoding().get(i), i); 455 } 456 if (element.hasTextElement()) { 457 composeString(t, "CodeableConcept", "text", element.getTextElement(), -1); 458 } 459 } 460 461 protected void composeCodeableReference(Complex parent, String parentType, String name, CodeableReference element, int index) { 462 if (element == null) 463 return; 464 Complex t; 465 if (Utilities.noString(parentType)) 466 t = parent; 467 else { 468 t = parent.predicate("fhir:"+name,index > -1); 469 } 470 composeDataType(t, "CodeableReference", name, element, index); 471 if (element.hasConcept()) { 472 composeCodeableConcept(t, "CodeableReference", "concept", element.getConcept(), -1); 473 } 474 if (element.hasReference()) { 475 composeReference(t, "CodeableReference", "reference", element.getReference(), -1); 476 } 477 } 478 479 protected void composeCoding(Complex parent, String parentType, String name, Coding element, int index) { 480 if (element == null) 481 return; 482 Complex t; 483 if (Utilities.noString(parentType)) 484 t = parent; 485 else { 486 t = parent.predicate("fhir:"+name,index > -1); 487 } 488 composeDataType(t, "Coding", name, element, index); 489 decorateCoding(t, element); 490 if (element.hasSystemElement()) { 491 composeUri(t, "Coding", "system", element.getSystemElement(), -1); 492 } 493 if (element.hasVersionElement()) { 494 composeString(t, "Coding", "version", element.getVersionElement(), -1); 495 } 496 if (element.hasCodeElement()) { 497 composeCode(t, "Coding", "code", element.getCodeElement(), -1); 498 } 499 if (element.hasDisplayElement()) { 500 composeString(t, "Coding", "display", element.getDisplayElement(), -1); 501 } 502 if (element.hasUserSelectedElement()) { 503 composeBoolean(t, "Coding", "userSelected", element.getUserSelectedElement(), -1); 504 } 505 } 506 507 protected void composeContactDetail(Complex parent, String parentType, String name, ContactDetail element, int index) { 508 if (element == null) 509 return; 510 Complex t; 511 if (Utilities.noString(parentType)) 512 t = parent; 513 else { 514 t = parent.predicate("fhir:"+name,index > -1); 515 } 516 composeDataType(t, "ContactDetail", name, element, index); 517 if (element.hasNameElement()) { 518 composeString(t, "ContactDetail", "name", element.getNameElement(), -1); 519 } 520 for (int i = 0; i < element.getTelecom().size(); i++) { 521 composeContactPoint(t, "ContactDetail", "telecom", element.getTelecom().get(i), i); 522 } 523 } 524 525 protected void composeContactPoint(Complex parent, String parentType, String name, ContactPoint element, int index) { 526 if (element == null) 527 return; 528 Complex t; 529 if (Utilities.noString(parentType)) 530 t = parent; 531 else { 532 t = parent.predicate("fhir:"+name,index > -1); 533 } 534 composeDataType(t, "ContactPoint", name, element, index); 535 if (element.hasSystemElement()) { 536 composeEnum(t, "ContactPoint", "system", element.getSystemElement(), -1); 537 } 538 if (element.hasValueElement()) { 539 composeString(t, "ContactPoint", "value", element.getValueElement(), -1); 540 } 541 if (element.hasUseElement()) { 542 composeEnum(t, "ContactPoint", "use", element.getUseElement(), -1); 543 } 544 if (element.hasRankElement()) { 545 composePositiveInt(t, "ContactPoint", "rank", element.getRankElement(), -1); 546 } 547 if (element.hasPeriod()) { 548 composePeriod(t, "ContactPoint", "period", element.getPeriod(), -1); 549 } 550 } 551 552 protected void composeContributor(Complex parent, String parentType, String name, Contributor element, int index) { 553 if (element == null) 554 return; 555 Complex t; 556 if (Utilities.noString(parentType)) 557 t = parent; 558 else { 559 t = parent.predicate("fhir:"+name,index > -1); 560 } 561 composeDataType(t, "Contributor", name, element, index); 562 if (element.hasTypeElement()) { 563 composeEnum(t, "Contributor", "type", element.getTypeElement(), -1); 564 } 565 if (element.hasNameElement()) { 566 composeString(t, "Contributor", "name", element.getNameElement(), -1); 567 } 568 for (int i = 0; i < element.getContact().size(); i++) { 569 composeContactDetail(t, "Contributor", "contact", element.getContact().get(i), i); 570 } 571 } 572 573 protected void composeCount(Complex parent, String parentType, String name, Count element, int index) { 574 if (element == null) 575 return; 576 Complex t; 577 if (Utilities.noString(parentType)) 578 t = parent; 579 else { 580 t = parent.predicate("fhir:"+name,index > -1); 581 } 582 composeQuantity(t, "Count", name, element, index); 583 } 584 585 protected void composeDataRequirement(Complex parent, String parentType, String name, DataRequirement element, int index) { 586 if (element == null) 587 return; 588 Complex t; 589 if (Utilities.noString(parentType)) 590 t = parent; 591 else { 592 t = parent.predicate("fhir:"+name,index > -1); 593 } 594 composeDataType(t, "DataRequirement", name, element, index); 595 if (element.hasTypeElement()) { 596 composeEnum(t, "DataRequirement", "type", element.getTypeElement(), -1); 597 } 598 for (int i = 0; i < element.getProfile().size(); i++) { 599 composeCanonical(t, "DataRequirement", "profile", element.getProfile().get(i), i); 600 } 601 if (element.hasSubject()) { 602 composeType(t, "DataRequirement", "subject", element.getSubject(), -1); 603 } 604 for (int i = 0; i < element.getMustSupport().size(); i++) { 605 composeString(t, "DataRequirement", "mustSupport", element.getMustSupport().get(i), i); 606 } 607 for (int i = 0; i < element.getCodeFilter().size(); i++) { 608 composeDataRequirementCodeFilterComponent(t, "DataRequirement", "codeFilter", element.getCodeFilter().get(i), i); 609 } 610 for (int i = 0; i < element.getDateFilter().size(); i++) { 611 composeDataRequirementDateFilterComponent(t, "DataRequirement", "dateFilter", element.getDateFilter().get(i), i); 612 } 613 for (int i = 0; i < element.getValueFilter().size(); i++) { 614 composeDataRequirementValueFilterComponent(t, "DataRequirement", "valueFilter", element.getValueFilter().get(i), i); 615 } 616 if (element.hasLimitElement()) { 617 composePositiveInt(t, "DataRequirement", "limit", element.getLimitElement(), -1); 618 } 619 for (int i = 0; i < element.getSort().size(); i++) { 620 composeDataRequirementSortComponent(t, "DataRequirement", "sort", element.getSort().get(i), i); 621 } 622 } 623 624 protected void composeDataRequirementCodeFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementCodeFilterComponent element, int index) { 625 if (element == null) 626 return; 627 Complex t; 628 if (Utilities.noString(parentType)) 629 t = parent; 630 else { 631 t = parent.predicate("fhir:"+name,index > -1); 632 } 633 composeElement(t, "codeFilter", name, element, index); 634 if (element.hasPathElement()) { 635 composeString(t, "DataRequirementCodeFilterComponent", "path", element.getPathElement(), -1); 636 } 637 if (element.hasSearchParamElement()) { 638 composeString(t, "DataRequirementCodeFilterComponent", "searchParam", element.getSearchParamElement(), -1); 639 } 640 if (element.hasValueSetElement()) { 641 composeCanonical(t, "DataRequirementCodeFilterComponent", "valueSet", element.getValueSetElement(), -1); 642 } 643 for (int i = 0; i < element.getCode().size(); i++) { 644 composeCoding(t, "DataRequirementCodeFilterComponent", "code", element.getCode().get(i), i); 645 } 646 } 647 648 protected void composeDataRequirementDateFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementDateFilterComponent element, int index) { 649 if (element == null) 650 return; 651 Complex t; 652 if (Utilities.noString(parentType)) 653 t = parent; 654 else { 655 t = parent.predicate("fhir:"+name,index > -1); 656 } 657 composeElement(t, "dateFilter", name, element, index); 658 if (element.hasPathElement()) { 659 composeString(t, "DataRequirementDateFilterComponent", "path", element.getPathElement(), -1); 660 } 661 if (element.hasSearchParamElement()) { 662 composeString(t, "DataRequirementDateFilterComponent", "searchParam", element.getSearchParamElement(), -1); 663 } 664 if (element.hasValue()) { 665 composeType(t, "DataRequirementDateFilterComponent", "value", element.getValue(), -1); 666 } 667 } 668 669 protected void composeDataRequirementValueFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementValueFilterComponent element, int index) { 670 if (element == null) 671 return; 672 Complex t; 673 if (Utilities.noString(parentType)) 674 t = parent; 675 else { 676 t = parent.predicate("fhir:"+name,index > -1); 677 } 678 composeElement(t, "valueFilter", name, element, index); 679 if (element.hasPathElement()) { 680 composeString(t, "DataRequirementValueFilterComponent", "path", element.getPathElement(), -1); 681 } 682 if (element.hasSearchParamElement()) { 683 composeString(t, "DataRequirementValueFilterComponent", "searchParam", element.getSearchParamElement(), -1); 684 } 685 if (element.hasComparatorElement()) { 686 composeEnum(t, "DataRequirementValueFilterComponent", "comparator", element.getComparatorElement(), -1); 687 } 688 if (element.hasValue()) { 689 composeType(t, "DataRequirementValueFilterComponent", "value", element.getValue(), -1); 690 } 691 } 692 693 protected void composeDataRequirementSortComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementSortComponent element, int index) { 694 if (element == null) 695 return; 696 Complex t; 697 if (Utilities.noString(parentType)) 698 t = parent; 699 else { 700 t = parent.predicate("fhir:"+name,index > -1); 701 } 702 composeElement(t, "sort", name, element, index); 703 if (element.hasPathElement()) { 704 composeString(t, "DataRequirementSortComponent", "path", element.getPathElement(), -1); 705 } 706 if (element.hasDirectionElement()) { 707 composeEnum(t, "DataRequirementSortComponent", "direction", element.getDirectionElement(), -1); 708 } 709 } 710 711 protected void composeDistance(Complex parent, String parentType, String name, Distance element, int index) { 712 if (element == null) 713 return; 714 Complex t; 715 if (Utilities.noString(parentType)) 716 t = parent; 717 else { 718 t = parent.predicate("fhir:"+name,index > -1); 719 } 720 composeQuantity(t, "Distance", name, element, index); 721 } 722 723 protected void composeDosage(Complex parent, String parentType, String name, Dosage element, int index) { 724 if (element == null) 725 return; 726 Complex t; 727 if (Utilities.noString(parentType)) 728 t = parent; 729 else { 730 t = parent.predicate("fhir:"+name,index > -1); 731 } 732 composeBackboneType(t, "Dosage", name, element, index); 733 if (element.hasSequenceElement()) { 734 composeInteger(t, "Dosage", "sequence", element.getSequenceElement(), -1); 735 } 736 if (element.hasTextElement()) { 737 composeString(t, "Dosage", "text", element.getTextElement(), -1); 738 } 739 for (int i = 0; i < element.getAdditionalInstruction().size(); i++) { 740 composeCodeableConcept(t, "Dosage", "additionalInstruction", element.getAdditionalInstruction().get(i), i); 741 } 742 if (element.hasPatientInstructionElement()) { 743 composeString(t, "Dosage", "patientInstruction", element.getPatientInstructionElement(), -1); 744 } 745 if (element.hasTiming()) { 746 composeTiming(t, "Dosage", "timing", element.getTiming(), -1); 747 } 748 if (element.hasAsNeededElement()) { 749 composeBoolean(t, "Dosage", "asNeeded", element.getAsNeededElement(), -1); 750 } 751 for (int i = 0; i < element.getAsNeededFor().size(); i++) { 752 composeCodeableConcept(t, "Dosage", "asNeededFor", element.getAsNeededFor().get(i), i); 753 } 754 if (element.hasSite()) { 755 composeCodeableConcept(t, "Dosage", "site", element.getSite(), -1); 756 } 757 if (element.hasRoute()) { 758 composeCodeableConcept(t, "Dosage", "route", element.getRoute(), -1); 759 } 760 if (element.hasMethod()) { 761 composeCodeableConcept(t, "Dosage", "method", element.getMethod(), -1); 762 } 763 for (int i = 0; i < element.getDoseAndRate().size(); i++) { 764 composeDosageDoseAndRateComponent(t, "Dosage", "doseAndRate", element.getDoseAndRate().get(i), i); 765 } 766 for (int i = 0; i < element.getMaxDosePerPeriod().size(); i++) { 767 composeRatio(t, "Dosage", "maxDosePerPeriod", element.getMaxDosePerPeriod().get(i), i); 768 } 769 if (element.hasMaxDosePerAdministration()) { 770 composeQuantity(t, "Dosage", "maxDosePerAdministration", element.getMaxDosePerAdministration(), -1); 771 } 772 if (element.hasMaxDosePerLifetime()) { 773 composeQuantity(t, "Dosage", "maxDosePerLifetime", element.getMaxDosePerLifetime(), -1); 774 } 775 } 776 777 protected void composeDosageDoseAndRateComponent(Complex parent, String parentType, String name, Dosage.DosageDoseAndRateComponent element, int index) { 778 if (element == null) 779 return; 780 Complex t; 781 if (Utilities.noString(parentType)) 782 t = parent; 783 else { 784 t = parent.predicate("fhir:"+name,index > -1); 785 } 786 composeElement(t, "doseAndRate", name, element, index); 787 if (element.hasType()) { 788 composeCodeableConcept(t, "DosageDoseAndRateComponent", "type", element.getType(), -1); 789 } 790 if (element.hasDose()) { 791 composeType(t, "DosageDoseAndRateComponent", "dose", element.getDose(), -1); 792 } 793 if (element.hasRate()) { 794 composeType(t, "DosageDoseAndRateComponent", "rate", element.getRate(), -1); 795 } 796 } 797 798 protected void composeDuration(Complex parent, String parentType, String name, Duration element, int index) { 799 if (element == null) 800 return; 801 Complex t; 802 if (Utilities.noString(parentType)) 803 t = parent; 804 else { 805 t = parent.predicate("fhir:"+name,index > -1); 806 } 807 composeQuantity(t, "Duration", name, element, index); 808 } 809 810 protected void composeElementDefinition(Complex parent, String parentType, String name, ElementDefinition element, int index) { 811 if (element == null) 812 return; 813 Complex t; 814 if (Utilities.noString(parentType)) 815 t = parent; 816 else { 817 t = parent.predicate("fhir:"+name,index > -1); 818 } 819 composeBackboneType(t, "ElementDefinition", name, element, index); 820 if (element.hasPathElement()) { 821 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 822 } 823 for (int i = 0; i < element.getRepresentation().size(); i++) { 824 composeEnum(t, "ElementDefinition", "representation", element.getRepresentation().get(i), i); 825 } 826 if (element.hasSliceNameElement()) { 827 composeString(t, "ElementDefinition", "sliceName", element.getSliceNameElement(), -1); 828 } 829 if (element.hasSliceIsConstrainingElement()) { 830 composeBoolean(t, "ElementDefinition", "sliceIsConstraining", element.getSliceIsConstrainingElement(), -1); 831 } 832 if (element.hasLabelElement()) { 833 composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1); 834 } 835 for (int i = 0; i < element.getCode().size(); i++) { 836 composeCoding(t, "ElementDefinition", "code", element.getCode().get(i), i); 837 } 838 if (element.hasSlicing()) { 839 composeElementDefinitionSlicingComponent(t, "ElementDefinition", "slicing", element.getSlicing(), -1); 840 } 841 if (element.hasShortElement()) { 842 composeString(t, "ElementDefinition", "short", element.getShortElement(), -1); 843 } 844 if (element.hasDefinitionElement()) { 845 composeMarkdown(t, "ElementDefinition", "definition", element.getDefinitionElement(), -1); 846 } 847 if (element.hasCommentElement()) { 848 composeMarkdown(t, "ElementDefinition", "comment", element.getCommentElement(), -1); 849 } 850 if (element.hasRequirementsElement()) { 851 composeMarkdown(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1); 852 } 853 for (int i = 0; i < element.getAlias().size(); i++) { 854 composeString(t, "ElementDefinition", "alias", element.getAlias().get(i), i); 855 } 856 if (element.hasMinElement()) { 857 composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1); 858 } 859 if (element.hasMaxElement()) { 860 composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1); 861 } 862 if (element.hasBase()) { 863 composeElementDefinitionBaseComponent(t, "ElementDefinition", "base", element.getBase(), -1); 864 } 865 if (element.hasContentReferenceElement()) { 866 composeUri(t, "ElementDefinition", "contentReference", element.getContentReferenceElement(), -1); 867 } 868 for (int i = 0; i < element.getType().size(); i++) { 869 composeElementDefinitionTypeRefComponent(t, "ElementDefinition", "type", element.getType().get(i), i); 870 } 871 if (element.hasDefaultValue()) { 872 composeType(t, "ElementDefinition", "defaultValue", element.getDefaultValue(), -1); 873 } 874 if (element.hasMeaningWhenMissingElement()) { 875 composeMarkdown(t, "ElementDefinition", "meaningWhenMissing", element.getMeaningWhenMissingElement(), -1); 876 } 877 if (element.hasOrderMeaningElement()) { 878 composeString(t, "ElementDefinition", "orderMeaning", element.getOrderMeaningElement(), -1); 879 } 880 if (element.hasFixed()) { 881 composeType(t, "ElementDefinition", "fixed", element.getFixed(), -1); 882 } 883 if (element.hasPattern()) { 884 composeType(t, "ElementDefinition", "pattern", element.getPattern(), -1); 885 } 886 for (int i = 0; i < element.getExample().size(); i++) { 887 composeElementDefinitionExampleComponent(t, "ElementDefinition", "example", element.getExample().get(i), i); 888 } 889 if (element.hasMinValue()) { 890 composeType(t, "ElementDefinition", "minValue", element.getMinValue(), -1); 891 } 892 if (element.hasMaxValue()) { 893 composeType(t, "ElementDefinition", "maxValue", element.getMaxValue(), -1); 894 } 895 if (element.hasMaxLengthElement()) { 896 composeInteger(t, "ElementDefinition", "maxLength", element.getMaxLengthElement(), -1); 897 } 898 for (int i = 0; i < element.getCondition().size(); i++) { 899 composeId(t, "ElementDefinition", "condition", element.getCondition().get(i), i); 900 } 901 for (int i = 0; i < element.getConstraint().size(); i++) { 902 composeElementDefinitionConstraintComponent(t, "ElementDefinition", "constraint", element.getConstraint().get(i), i); 903 } 904 if (element.hasMustHaveValueElement()) { 905 composeBoolean(t, "ElementDefinition", "mustHaveValue", element.getMustHaveValueElement(), -1); 906 } 907 for (int i = 0; i < element.getValueAlternatives().size(); i++) { 908 composeCanonical(t, "ElementDefinition", "valueAlternatives", element.getValueAlternatives().get(i), i); 909 } 910 if (element.hasMustSupportElement()) { 911 composeBoolean(t, "ElementDefinition", "mustSupport", element.getMustSupportElement(), -1); 912 } 913 if (element.hasIsModifierElement()) { 914 composeBoolean(t, "ElementDefinition", "isModifier", element.getIsModifierElement(), -1); 915 } 916 if (element.hasIsModifierReasonElement()) { 917 composeString(t, "ElementDefinition", "isModifierReason", element.getIsModifierReasonElement(), -1); 918 } 919 if (element.hasIsSummaryElement()) { 920 composeBoolean(t, "ElementDefinition", "isSummary", element.getIsSummaryElement(), -1); 921 } 922 if (element.hasBinding()) { 923 composeElementDefinitionBindingComponent(t, "ElementDefinition", "binding", element.getBinding(), -1); 924 } 925 for (int i = 0; i < element.getMapping().size(); i++) { 926 composeElementDefinitionMappingComponent(t, "ElementDefinition", "mapping", element.getMapping().get(i), i); 927 } 928 } 929 930 protected void composeElementDefinitionSlicingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingComponent element, int index) { 931 if (element == null) 932 return; 933 Complex t; 934 if (Utilities.noString(parentType)) 935 t = parent; 936 else { 937 t = parent.predicate("fhir:"+name,index > -1); 938 } 939 composeElement(t, "slicing", name, element, index); 940 for (int i = 0; i < element.getDiscriminator().size(); i++) { 941 composeElementDefinitionSlicingDiscriminatorComponent(t, "ElementDefinitionSlicingComponent", "discriminator", element.getDiscriminator().get(i), i); 942 } 943 if (element.hasDescriptionElement()) { 944 composeString(t, "ElementDefinitionSlicingComponent", "description", element.getDescriptionElement(), -1); 945 } 946 if (element.hasOrderedElement()) { 947 composeBoolean(t, "ElementDefinitionSlicingComponent", "ordered", element.getOrderedElement(), -1); 948 } 949 if (element.hasRulesElement()) { 950 composeEnum(t, "ElementDefinitionSlicingComponent", "rules", element.getRulesElement(), -1); 951 } 952 } 953 954 protected void composeElementDefinitionSlicingDiscriminatorComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent element, int index) { 955 if (element == null) 956 return; 957 Complex t; 958 if (Utilities.noString(parentType)) 959 t = parent; 960 else { 961 t = parent.predicate("fhir:"+name,index > -1); 962 } 963 composeElement(t, "discriminator", name, element, index); 964 if (element.hasTypeElement()) { 965 composeEnum(t, "ElementDefinitionSlicingDiscriminatorComponent", "type", element.getTypeElement(), -1); 966 } 967 if (element.hasPathElement()) { 968 composeString(t, "ElementDefinitionSlicingDiscriminatorComponent", "path", element.getPathElement(), -1); 969 } 970 } 971 972 protected void composeElementDefinitionBaseComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBaseComponent element, int index) { 973 if (element == null) 974 return; 975 Complex t; 976 if (Utilities.noString(parentType)) 977 t = parent; 978 else { 979 t = parent.predicate("fhir:"+name,index > -1); 980 } 981 composeElement(t, "base", name, element, index); 982 if (element.hasPathElement()) { 983 composeString(t, "ElementDefinitionBaseComponent", "path", element.getPathElement(), -1); 984 } 985 if (element.hasMinElement()) { 986 composeUnsignedInt(t, "ElementDefinitionBaseComponent", "min", element.getMinElement(), -1); 987 } 988 if (element.hasMaxElement()) { 989 composeString(t, "ElementDefinitionBaseComponent", "max", element.getMaxElement(), -1); 990 } 991 } 992 993 protected void composeElementDefinitionTypeRefComponent(Complex parent, String parentType, String name, ElementDefinition.TypeRefComponent element, int index) { 994 if (element == null) 995 return; 996 Complex t; 997 if (Utilities.noString(parentType)) 998 t = parent; 999 else { 1000 t = parent.predicate("fhir:"+name,index > -1); 1001 } 1002 composeElement(t, "type", name, element, index); 1003 if (element.hasCodeElement()) { 1004 composeUri(t, "TypeRefComponent", "code", element.getCodeElement(), -1); 1005 } 1006 for (int i = 0; i < element.getProfile().size(); i++) { 1007 composeCanonical(t, "TypeRefComponent", "profile", element.getProfile().get(i), i); 1008 } 1009 for (int i = 0; i < element.getTargetProfile().size(); i++) { 1010 composeCanonical(t, "TypeRefComponent", "targetProfile", element.getTargetProfile().get(i), i); 1011 } 1012 for (int i = 0; i < element.getAggregation().size(); i++) { 1013 composeEnum(t, "TypeRefComponent", "aggregation", element.getAggregation().get(i), i); 1014 } 1015 if (element.hasVersioningElement()) { 1016 composeEnum(t, "TypeRefComponent", "versioning", element.getVersioningElement(), -1); 1017 } 1018 } 1019 1020 protected void composeElementDefinitionExampleComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionExampleComponent element, int index) { 1021 if (element == null) 1022 return; 1023 Complex t; 1024 if (Utilities.noString(parentType)) 1025 t = parent; 1026 else { 1027 t = parent.predicate("fhir:"+name,index > -1); 1028 } 1029 composeElement(t, "example", name, element, index); 1030 if (element.hasLabelElement()) { 1031 composeString(t, "ElementDefinitionExampleComponent", "label", element.getLabelElement(), -1); 1032 } 1033 if (element.hasValue()) { 1034 composeType(t, "ElementDefinitionExampleComponent", "value", element.getValue(), -1); 1035 } 1036 } 1037 1038 protected void composeElementDefinitionConstraintComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionConstraintComponent element, int index) { 1039 if (element == null) 1040 return; 1041 Complex t; 1042 if (Utilities.noString(parentType)) 1043 t = parent; 1044 else { 1045 t = parent.predicate("fhir:"+name,index > -1); 1046 } 1047 composeElement(t, "constraint", name, element, index); 1048 if (element.hasKeyElement()) { 1049 composeId(t, "ElementDefinitionConstraintComponent", "key", element.getKeyElement(), -1); 1050 } 1051 if (element.hasRequirementsElement()) { 1052 composeMarkdown(t, "ElementDefinitionConstraintComponent", "requirements", element.getRequirementsElement(), -1); 1053 } 1054 if (element.hasSeverityElement()) { 1055 composeEnum(t, "ElementDefinitionConstraintComponent", "severity", element.getSeverityElement(), -1); 1056 } 1057 if (element.hasSuppressElement()) { 1058 composeBoolean(t, "ElementDefinitionConstraintComponent", "suppress", element.getSuppressElement(), -1); 1059 } 1060 if (element.hasHumanElement()) { 1061 composeString(t, "ElementDefinitionConstraintComponent", "human", element.getHumanElement(), -1); 1062 } 1063 if (element.hasExpressionElement()) { 1064 composeString(t, "ElementDefinitionConstraintComponent", "expression", element.getExpressionElement(), -1); 1065 } 1066 if (element.hasSourceElement()) { 1067 composeCanonical(t, "ElementDefinitionConstraintComponent", "source", element.getSourceElement(), -1); 1068 } 1069 } 1070 1071 protected void composeElementDefinitionBindingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingComponent element, int index) { 1072 if (element == null) 1073 return; 1074 Complex t; 1075 if (Utilities.noString(parentType)) 1076 t = parent; 1077 else { 1078 t = parent.predicate("fhir:"+name,index > -1); 1079 } 1080 composeElement(t, "binding", name, element, index); 1081 if (element.hasStrengthElement()) { 1082 composeEnum(t, "ElementDefinitionBindingComponent", "strength", element.getStrengthElement(), -1); 1083 } 1084 if (element.hasDescriptionElement()) { 1085 composeMarkdown(t, "ElementDefinitionBindingComponent", "description", element.getDescriptionElement(), -1); 1086 } 1087 if (element.hasValueSetElement()) { 1088 composeCanonical(t, "ElementDefinitionBindingComponent", "valueSet", element.getValueSetElement(), -1); 1089 } 1090 for (int i = 0; i < element.getAdditional().size(); i++) { 1091 composeElementDefinitionBindingAdditionalComponent(t, "ElementDefinitionBindingComponent", "additional", element.getAdditional().get(i), i); 1092 } 1093 } 1094 1095 protected void composeElementDefinitionBindingAdditionalComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingAdditionalComponent element, int index) { 1096 if (element == null) 1097 return; 1098 Complex t; 1099 if (Utilities.noString(parentType)) 1100 t = parent; 1101 else { 1102 t = parent.predicate("fhir:"+name,index > -1); 1103 } 1104 composeElement(t, "additional", name, element, index); 1105 if (element.hasPurposeElement()) { 1106 composeEnum(t, "ElementDefinitionBindingAdditionalComponent", "purpose", element.getPurposeElement(), -1); 1107 } 1108 if (element.hasValueSetElement()) { 1109 composeCanonical(t, "ElementDefinitionBindingAdditionalComponent", "valueSet", element.getValueSetElement(), -1); 1110 } 1111 if (element.hasDocumentationElement()) { 1112 composeMarkdown(t, "ElementDefinitionBindingAdditionalComponent", "documentation", element.getDocumentationElement(), -1); 1113 } 1114 if (element.hasShortDocoElement()) { 1115 composeString(t, "ElementDefinitionBindingAdditionalComponent", "shortDoco", element.getShortDocoElement(), -1); 1116 } 1117 for (int i = 0; i < element.getUsage().size(); i++) { 1118 composeUsageContext(t, "ElementDefinitionBindingAdditionalComponent", "usage", element.getUsage().get(i), i); 1119 } 1120 if (element.hasAnyElement()) { 1121 composeBoolean(t, "ElementDefinitionBindingAdditionalComponent", "any", element.getAnyElement(), -1); 1122 } 1123 } 1124 1125 protected void composeElementDefinitionMappingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionMappingComponent element, int index) { 1126 if (element == null) 1127 return; 1128 Complex t; 1129 if (Utilities.noString(parentType)) 1130 t = parent; 1131 else { 1132 t = parent.predicate("fhir:"+name,index > -1); 1133 } 1134 composeElement(t, "mapping", name, element, index); 1135 if (element.hasIdentityElement()) { 1136 composeId(t, "ElementDefinitionMappingComponent", "identity", element.getIdentityElement(), -1); 1137 } 1138 if (element.hasLanguageElement()) { 1139 composeCode(t, "ElementDefinitionMappingComponent", "language", element.getLanguageElement(), -1); 1140 } 1141 if (element.hasMapElement()) { 1142 composeString(t, "ElementDefinitionMappingComponent", "map", element.getMapElement(), -1); 1143 } 1144 if (element.hasCommentElement()) { 1145 composeMarkdown(t, "ElementDefinitionMappingComponent", "comment", element.getCommentElement(), -1); 1146 } 1147 } 1148 1149 protected void composeExpression(Complex parent, String parentType, String name, Expression element, int index) { 1150 if (element == null) 1151 return; 1152 Complex t; 1153 if (Utilities.noString(parentType)) 1154 t = parent; 1155 else { 1156 t = parent.predicate("fhir:"+name,index > -1); 1157 } 1158 composeDataType(t, "Expression", name, element, index); 1159 if (element.hasDescriptionElement()) { 1160 composeString(t, "Expression", "description", element.getDescriptionElement(), -1); 1161 } 1162 if (element.hasNameElement()) { 1163 composeCode(t, "Expression", "name", element.getNameElement(), -1); 1164 } 1165 if (element.hasLanguageElement()) { 1166 composeCode(t, "Expression", "language", element.getLanguageElement(), -1); 1167 } 1168 if (element.hasExpressionElement()) { 1169 composeString(t, "Expression", "expression", element.getExpressionElement(), -1); 1170 } 1171 if (element.hasReferenceElement()) { 1172 composeUri(t, "Expression", "reference", element.getReferenceElement(), -1); 1173 } 1174 } 1175 1176 protected void composeExtendedContactDetail(Complex parent, String parentType, String name, ExtendedContactDetail element, int index) { 1177 if (element == null) 1178 return; 1179 Complex t; 1180 if (Utilities.noString(parentType)) 1181 t = parent; 1182 else { 1183 t = parent.predicate("fhir:"+name,index > -1); 1184 } 1185 composeDataType(t, "ExtendedContactDetail", name, element, index); 1186 if (element.hasPurpose()) { 1187 composeCodeableConcept(t, "ExtendedContactDetail", "purpose", element.getPurpose(), -1); 1188 } 1189 for (int i = 0; i < element.getName().size(); i++) { 1190 composeHumanName(t, "ExtendedContactDetail", "name", element.getName().get(i), i); 1191 } 1192 for (int i = 0; i < element.getTelecom().size(); i++) { 1193 composeContactPoint(t, "ExtendedContactDetail", "telecom", element.getTelecom().get(i), i); 1194 } 1195 if (element.hasAddress()) { 1196 composeAddress(t, "ExtendedContactDetail", "address", element.getAddress(), -1); 1197 } 1198 if (element.hasOrganization()) { 1199 composeReference(t, "ExtendedContactDetail", "organization", element.getOrganization(), -1); 1200 } 1201 if (element.hasPeriod()) { 1202 composePeriod(t, "ExtendedContactDetail", "period", element.getPeriod(), -1); 1203 } 1204 } 1205 1206 protected void composeExtension(Complex parent, String parentType, String name, Extension element, int index) { 1207 if (element == null) 1208 return; 1209 Complex t; 1210 if (Utilities.noString(parentType)) 1211 t = parent; 1212 else { 1213 t = parent.predicate("fhir:"+name,index > -1); 1214 } 1215 composeDataType(t, "Extension", name, element, index); 1216 if (element.hasUrlElement()) { 1217 composeUri(t, "Extension", "url", element.getUrlElement(), -1); 1218 } 1219 if (element.hasValue()) { 1220 composeType(t, "Extension", "value", element.getValue(), -1); 1221 } 1222 } 1223 1224 protected void composeHumanName(Complex parent, String parentType, String name, HumanName element, int index) { 1225 if (element == null) 1226 return; 1227 Complex t; 1228 if (Utilities.noString(parentType)) 1229 t = parent; 1230 else { 1231 t = parent.predicate("fhir:"+name,index > -1); 1232 } 1233 composeDataType(t, "HumanName", name, element, index); 1234 if (element.hasUseElement()) { 1235 composeEnum(t, "HumanName", "use", element.getUseElement(), -1); 1236 } 1237 if (element.hasTextElement()) { 1238 composeString(t, "HumanName", "text", element.getTextElement(), -1); 1239 } 1240 if (element.hasFamilyElement()) { 1241 composeString(t, "HumanName", "family", element.getFamilyElement(), -1); 1242 } 1243 for (int i = 0; i < element.getGiven().size(); i++) { 1244 composeString(t, "HumanName", "given", element.getGiven().get(i), i); 1245 } 1246 for (int i = 0; i < element.getPrefix().size(); i++) { 1247 composeString(t, "HumanName", "prefix", element.getPrefix().get(i), i); 1248 } 1249 for (int i = 0; i < element.getSuffix().size(); i++) { 1250 composeString(t, "HumanName", "suffix", element.getSuffix().get(i), i); 1251 } 1252 if (element.hasPeriod()) { 1253 composePeriod(t, "HumanName", "period", element.getPeriod(), -1); 1254 } 1255 } 1256 1257 protected void composeIdentifier(Complex parent, String parentType, String name, Identifier element, int index) { 1258 if (element == null) 1259 return; 1260 Complex t; 1261 if (Utilities.noString(parentType)) 1262 t = parent; 1263 else { 1264 t = parent.predicate("fhir:"+name,index > -1); 1265 } 1266 composeDataType(t, "Identifier", name, element, index); 1267 if (element.hasUseElement()) { 1268 composeEnum(t, "Identifier", "use", element.getUseElement(), -1); 1269 } 1270 if (element.hasType()) { 1271 composeCodeableConcept(t, "Identifier", "type", element.getType(), -1); 1272 } 1273 if (element.hasSystemElement()) { 1274 composeUri(t, "Identifier", "system", element.getSystemElement(), -1); 1275 } 1276 if (element.hasValueElement()) { 1277 composeString(t, "Identifier", "value", element.getValueElement(), -1); 1278 } 1279 if (element.hasPeriod()) { 1280 composePeriod(t, "Identifier", "period", element.getPeriod(), -1); 1281 } 1282 if (element.hasAssigner()) { 1283 composeReference(t, "Identifier", "assigner", element.getAssigner(), -1); 1284 } 1285 } 1286 1287 protected void composeMarketingStatus(Complex parent, String parentType, String name, MarketingStatus element, int index) { 1288 if (element == null) 1289 return; 1290 Complex t; 1291 if (Utilities.noString(parentType)) 1292 t = parent; 1293 else { 1294 t = parent.predicate("fhir:"+name,index > -1); 1295 } 1296 composeBackboneType(t, "MarketingStatus", name, element, index); 1297 if (element.hasCountry()) { 1298 composeCodeableConcept(t, "MarketingStatus", "country", element.getCountry(), -1); 1299 } 1300 if (element.hasJurisdiction()) { 1301 composeCodeableConcept(t, "MarketingStatus", "jurisdiction", element.getJurisdiction(), -1); 1302 } 1303 if (element.hasStatus()) { 1304 composeCodeableConcept(t, "MarketingStatus", "status", element.getStatus(), -1); 1305 } 1306 if (element.hasDateRange()) { 1307 composePeriod(t, "MarketingStatus", "dateRange", element.getDateRange(), -1); 1308 } 1309 if (element.hasRestoreDateElement()) { 1310 composeDateTime(t, "MarketingStatus", "restoreDate", element.getRestoreDateElement(), -1); 1311 } 1312 } 1313 1314 protected void composeMeta(Complex parent, String parentType, String name, Meta element, int index) { 1315 if (element == null) 1316 return; 1317 Complex t; 1318 if (Utilities.noString(parentType)) 1319 t = parent; 1320 else { 1321 t = parent.predicate("fhir:"+name,index > -1); 1322 } 1323 composeDataType(t, "Meta", name, element, index); 1324 if (element.hasVersionIdElement()) { 1325 composeId(t, "Meta", "versionId", element.getVersionIdElement(), -1); 1326 } 1327 if (element.hasLastUpdatedElement()) { 1328 composeInstant(t, "Meta", "lastUpdated", element.getLastUpdatedElement(), -1); 1329 } 1330 if (element.hasSourceElement()) { 1331 composeUri(t, "Meta", "source", element.getSourceElement(), -1); 1332 } 1333 for (int i = 0; i < element.getProfile().size(); i++) { 1334 composeCanonical(t, "Meta", "profile", element.getProfile().get(i), i); 1335 } 1336 for (int i = 0; i < element.getSecurity().size(); i++) { 1337 composeCoding(t, "Meta", "security", element.getSecurity().get(i), i); 1338 } 1339 for (int i = 0; i < element.getTag().size(); i++) { 1340 composeCoding(t, "Meta", "tag", element.getTag().get(i), i); 1341 } 1342 } 1343 1344 protected void composeMonetaryComponent(Complex parent, String parentType, String name, MonetaryComponent element, int index) { 1345 if (element == null) 1346 return; 1347 Complex t; 1348 if (Utilities.noString(parentType)) 1349 t = parent; 1350 else { 1351 t = parent.predicate("fhir:"+name,index > -1); 1352 } 1353 composeDataType(t, "MonetaryComponent", name, element, index); 1354 if (element.hasTypeElement()) { 1355 composeEnum(t, "MonetaryComponent", "type", element.getTypeElement(), -1); 1356 } 1357 if (element.hasCode()) { 1358 composeCodeableConcept(t, "MonetaryComponent", "code", element.getCode(), -1); 1359 } 1360 if (element.hasFactorElement()) { 1361 composeDecimal(t, "MonetaryComponent", "factor", element.getFactorElement(), -1); 1362 } 1363 if (element.hasAmount()) { 1364 composeMoney(t, "MonetaryComponent", "amount", element.getAmount(), -1); 1365 } 1366 } 1367 1368 protected void composeMoney(Complex parent, String parentType, String name, Money element, int index) { 1369 if (element == null) 1370 return; 1371 Complex t; 1372 if (Utilities.noString(parentType)) 1373 t = parent; 1374 else { 1375 t = parent.predicate("fhir:"+name,index > -1); 1376 } 1377 composeDataType(t, "Money", name, element, index); 1378 if (element.hasValueElement()) { 1379 composeDecimal(t, "Money", "value", element.getValueElement(), -1); 1380 } 1381 if (element.hasCurrencyElement()) { 1382 composeCode(t, "Money", "currency", element.getCurrencyElement(), -1); 1383 } 1384 } 1385 1386 protected void composeNarrative(Complex parent, String parentType, String name, Narrative element, int index) { 1387 if (element == null) 1388 return; 1389 Complex t; 1390 if (Utilities.noString(parentType)) 1391 t = parent; 1392 else { 1393 t = parent.predicate("fhir:"+name,index > -1); 1394 } 1395 composeDataType(t, "Narrative", name, element, index); 1396 if (element.hasStatusElement()) { 1397 composeEnum(t, "Narrative", "status", element.getStatusElement(), -1); 1398 } 1399 if (element.hasDiv()) { 1400 composeXhtmlNode(t, "Narrative", "div", element.getDiv(), -1); 1401 } 1402 } 1403 1404 protected void composeParameterDefinition(Complex parent, String parentType, String name, ParameterDefinition element, int index) { 1405 if (element == null) 1406 return; 1407 Complex t; 1408 if (Utilities.noString(parentType)) 1409 t = parent; 1410 else { 1411 t = parent.predicate("fhir:"+name,index > -1); 1412 } 1413 composeDataType(t, "ParameterDefinition", name, element, index); 1414 if (element.hasNameElement()) { 1415 composeCode(t, "ParameterDefinition", "name", element.getNameElement(), -1); 1416 } 1417 if (element.hasUseElement()) { 1418 composeEnum(t, "ParameterDefinition", "use", element.getUseElement(), -1); 1419 } 1420 if (element.hasMinElement()) { 1421 composeInteger(t, "ParameterDefinition", "min", element.getMinElement(), -1); 1422 } 1423 if (element.hasMaxElement()) { 1424 composeString(t, "ParameterDefinition", "max", element.getMaxElement(), -1); 1425 } 1426 if (element.hasDocumentationElement()) { 1427 composeString(t, "ParameterDefinition", "documentation", element.getDocumentationElement(), -1); 1428 } 1429 if (element.hasTypeElement()) { 1430 composeEnum(t, "ParameterDefinition", "type", element.getTypeElement(), -1); 1431 } 1432 if (element.hasProfileElement()) { 1433 composeCanonical(t, "ParameterDefinition", "profile", element.getProfileElement(), -1); 1434 } 1435 } 1436 1437 protected void composePeriod(Complex parent, String parentType, String name, Period element, int index) { 1438 if (element == null) 1439 return; 1440 Complex t; 1441 if (Utilities.noString(parentType)) 1442 t = parent; 1443 else { 1444 t = parent.predicate("fhir:"+name,index > -1); 1445 } 1446 composeDataType(t, "Period", name, element, index); 1447 if (element.hasStartElement()) { 1448 composeDateTime(t, "Period", "start", element.getStartElement(), -1); 1449 } 1450 if (element.hasEndElement()) { 1451 composeDateTime(t, "Period", "end", element.getEndElement(), -1); 1452 } 1453 } 1454 1455 protected void composeProductShelfLife(Complex parent, String parentType, String name, ProductShelfLife element, int index) { 1456 if (element == null) 1457 return; 1458 Complex t; 1459 if (Utilities.noString(parentType)) 1460 t = parent; 1461 else { 1462 t = parent.predicate("fhir:"+name,index > -1); 1463 } 1464 composeBackboneType(t, "ProductShelfLife", name, element, index); 1465 if (element.hasType()) { 1466 composeCodeableConcept(t, "ProductShelfLife", "type", element.getType(), -1); 1467 } 1468 if (element.hasPeriod()) { 1469 composeType(t, "ProductShelfLife", "period", element.getPeriod(), -1); 1470 } 1471 for (int i = 0; i < element.getSpecialPrecautionsForStorage().size(); i++) { 1472 composeCodeableConcept(t, "ProductShelfLife", "specialPrecautionsForStorage", element.getSpecialPrecautionsForStorage().get(i), i); 1473 } 1474 } 1475 1476 protected void composeQuantity(Complex parent, String parentType, String name, Quantity element, int index) { 1477 if (element == null) 1478 return; 1479 Complex t; 1480 if (Utilities.noString(parentType)) 1481 t = parent; 1482 else { 1483 t = parent.predicate("fhir:"+name,index > -1); 1484 } 1485 composeDataType(t, "Quantity", name, element, index); 1486 if (element.hasValueElement()) { 1487 composeDecimal(t, "Quantity", "value", element.getValueElement(), -1); 1488 } 1489 if (element.hasComparatorElement()) { 1490 composeEnum(t, "Quantity", "comparator", element.getComparatorElement(), -1); 1491 } 1492 if (element.hasUnitElement()) { 1493 composeString(t, "Quantity", "unit", element.getUnitElement(), -1); 1494 } 1495 if (element.hasSystemElement()) { 1496 composeUri(t, "Quantity", "system", element.getSystemElement(), -1); 1497 } 1498 if (element.hasCodeElement()) { 1499 composeCode(t, "Quantity", "code", element.getCodeElement(), -1); 1500 } 1501 } 1502 1503 protected void composeRange(Complex parent, String parentType, String name, Range element, int index) { 1504 if (element == null) 1505 return; 1506 Complex t; 1507 if (Utilities.noString(parentType)) 1508 t = parent; 1509 else { 1510 t = parent.predicate("fhir:"+name,index > -1); 1511 } 1512 composeDataType(t, "Range", name, element, index); 1513 if (element.hasLow()) { 1514 composeQuantity(t, "Range", "low", element.getLow(), -1); 1515 } 1516 if (element.hasHigh()) { 1517 composeQuantity(t, "Range", "high", element.getHigh(), -1); 1518 } 1519 } 1520 1521 protected void composeRatio(Complex parent, String parentType, String name, Ratio element, int index) { 1522 if (element == null) 1523 return; 1524 Complex t; 1525 if (Utilities.noString(parentType)) 1526 t = parent; 1527 else { 1528 t = parent.predicate("fhir:"+name,index > -1); 1529 } 1530 composeDataType(t, "Ratio", name, element, index); 1531 if (element.hasNumerator()) { 1532 composeQuantity(t, "Ratio", "numerator", element.getNumerator(), -1); 1533 } 1534 if (element.hasDenominator()) { 1535 composeQuantity(t, "Ratio", "denominator", element.getDenominator(), -1); 1536 } 1537 } 1538 1539 protected void composeRatioRange(Complex parent, String parentType, String name, RatioRange element, int index) { 1540 if (element == null) 1541 return; 1542 Complex t; 1543 if (Utilities.noString(parentType)) 1544 t = parent; 1545 else { 1546 t = parent.predicate("fhir:"+name,index > -1); 1547 } 1548 composeDataType(t, "RatioRange", name, element, index); 1549 if (element.hasLowNumerator()) { 1550 composeQuantity(t, "RatioRange", "lowNumerator", element.getLowNumerator(), -1); 1551 } 1552 if (element.hasHighNumerator()) { 1553 composeQuantity(t, "RatioRange", "highNumerator", element.getHighNumerator(), -1); 1554 } 1555 if (element.hasDenominator()) { 1556 composeQuantity(t, "RatioRange", "denominator", element.getDenominator(), -1); 1557 } 1558 } 1559 1560 protected void composeReference(Complex parent, String parentType, String name, Reference element, int index) { 1561 if (element == null) 1562 return; 1563 Complex t; 1564 if (Utilities.noString(parentType)) 1565 t = parent; 1566 else { 1567 t = parent.predicate("fhir:"+name,index > -1); 1568 } 1569 composeDataType(t, "Reference", name, element, index); 1570 if (element.hasReferenceElement()) { 1571 composeString(t, "Reference", "reference", element.getReferenceElement_(), -1); 1572 } 1573 if (element.hasTypeElement()) { 1574 composeUri(t, "Reference", "type", element.getTypeElement(), -1); 1575 } 1576 if (element.hasIdentifier()) { 1577 composeIdentifier(t, "Reference", "identifier", element.getIdentifier(), -1); 1578 } 1579 if (element.hasDisplayElement()) { 1580 composeString(t, "Reference", "display", element.getDisplayElement(), -1); 1581 } 1582 } 1583 1584 protected void composeRelatedArtifact(Complex parent, String parentType, String name, RelatedArtifact element, int index) { 1585 if (element == null) 1586 return; 1587 Complex t; 1588 if (Utilities.noString(parentType)) 1589 t = parent; 1590 else { 1591 t = parent.predicate("fhir:"+name,index > -1); 1592 } 1593 composeDataType(t, "RelatedArtifact", name, element, index); 1594 if (element.hasTypeElement()) { 1595 composeEnum(t, "RelatedArtifact", "type", element.getTypeElement(), -1); 1596 } 1597 for (int i = 0; i < element.getClassifier().size(); i++) { 1598 composeCodeableConcept(t, "RelatedArtifact", "classifier", element.getClassifier().get(i), i); 1599 } 1600 if (element.hasLabelElement()) { 1601 composeString(t, "RelatedArtifact", "label", element.getLabelElement(), -1); 1602 } 1603 if (element.hasDisplayElement()) { 1604 composeString(t, "RelatedArtifact", "display", element.getDisplayElement(), -1); 1605 } 1606 if (element.hasCitationElement()) { 1607 composeMarkdown(t, "RelatedArtifact", "citation", element.getCitationElement(), -1); 1608 } 1609 if (element.hasDocument()) { 1610 composeAttachment(t, "RelatedArtifact", "document", element.getDocument(), -1); 1611 } 1612 if (element.hasResourceElement()) { 1613 composeCanonical(t, "RelatedArtifact", "resource", element.getResourceElement(), -1); 1614 } 1615 if (element.hasResourceReference()) { 1616 composeReference(t, "RelatedArtifact", "resourceReference", element.getResourceReference(), -1); 1617 } 1618 if (element.hasPublicationStatusElement()) { 1619 composeEnum(t, "RelatedArtifact", "publicationStatus", element.getPublicationStatusElement(), -1); 1620 } 1621 if (element.hasPublicationDateElement()) { 1622 composeDate(t, "RelatedArtifact", "publicationDate", element.getPublicationDateElement(), -1); 1623 } 1624 } 1625 1626 protected void composeSampledData(Complex parent, String parentType, String name, SampledData element, int index) { 1627 if (element == null) 1628 return; 1629 Complex t; 1630 if (Utilities.noString(parentType)) 1631 t = parent; 1632 else { 1633 t = parent.predicate("fhir:"+name,index > -1); 1634 } 1635 composeDataType(t, "SampledData", name, element, index); 1636 if (element.hasOrigin()) { 1637 composeQuantity(t, "SampledData", "origin", element.getOrigin(), -1); 1638 } 1639 if (element.hasIntervalElement()) { 1640 composeDecimal(t, "SampledData", "interval", element.getIntervalElement(), -1); 1641 } 1642 if (element.hasIntervalUnitElement()) { 1643 composeCode(t, "SampledData", "intervalUnit", element.getIntervalUnitElement(), -1); 1644 } 1645 if (element.hasFactorElement()) { 1646 composeDecimal(t, "SampledData", "factor", element.getFactorElement(), -1); 1647 } 1648 if (element.hasLowerLimitElement()) { 1649 composeDecimal(t, "SampledData", "lowerLimit", element.getLowerLimitElement(), -1); 1650 } 1651 if (element.hasUpperLimitElement()) { 1652 composeDecimal(t, "SampledData", "upperLimit", element.getUpperLimitElement(), -1); 1653 } 1654 if (element.hasDimensionsElement()) { 1655 composePositiveInt(t, "SampledData", "dimensions", element.getDimensionsElement(), -1); 1656 } 1657 if (element.hasCodeMapElement()) { 1658 composeCanonical(t, "SampledData", "codeMap", element.getCodeMapElement(), -1); 1659 } 1660 if (element.hasOffsetsElement()) { 1661 composeString(t, "SampledData", "offsets", element.getOffsetsElement(), -1); 1662 } 1663 if (element.hasDataElement()) { 1664 composeString(t, "SampledData", "data", element.getDataElement(), -1); 1665 } 1666 } 1667 1668 protected void composeSignature(Complex parent, String parentType, String name, Signature element, int index) { 1669 if (element == null) 1670 return; 1671 Complex t; 1672 if (Utilities.noString(parentType)) 1673 t = parent; 1674 else { 1675 t = parent.predicate("fhir:"+name,index > -1); 1676 } 1677 composeDataType(t, "Signature", name, element, index); 1678 for (int i = 0; i < element.getType().size(); i++) { 1679 composeCoding(t, "Signature", "type", element.getType().get(i), i); 1680 } 1681 if (element.hasWhenElement()) { 1682 composeInstant(t, "Signature", "when", element.getWhenElement(), -1); 1683 } 1684 if (element.hasWho()) { 1685 composeReference(t, "Signature", "who", element.getWho(), -1); 1686 } 1687 if (element.hasOnBehalfOf()) { 1688 composeReference(t, "Signature", "onBehalfOf", element.getOnBehalfOf(), -1); 1689 } 1690 if (element.hasTargetFormatElement()) { 1691 composeCode(t, "Signature", "targetFormat", element.getTargetFormatElement(), -1); 1692 } 1693 if (element.hasSigFormatElement()) { 1694 composeCode(t, "Signature", "sigFormat", element.getSigFormatElement(), -1); 1695 } 1696 if (element.hasDataElement()) { 1697 composeBase64Binary(t, "Signature", "data", element.getDataElement(), -1); 1698 } 1699 } 1700 1701 protected void composeTiming(Complex parent, String parentType, String name, Timing element, int index) { 1702 if (element == null) 1703 return; 1704 Complex t; 1705 if (Utilities.noString(parentType)) 1706 t = parent; 1707 else { 1708 t = parent.predicate("fhir:"+name,index > -1); 1709 } 1710 composeBackboneType(t, "Timing", name, element, index); 1711 for (int i = 0; i < element.getEvent().size(); i++) { 1712 composeDateTime(t, "Timing", "event", element.getEvent().get(i), i); 1713 } 1714 if (element.hasRepeat()) { 1715 composeTimingRepeatComponent(t, "Timing", "repeat", element.getRepeat(), -1); 1716 } 1717 if (element.hasCode()) { 1718 composeCodeableConcept(t, "Timing", "code", element.getCode(), -1); 1719 } 1720 } 1721 1722 protected void composeTimingRepeatComponent(Complex parent, String parentType, String name, Timing.TimingRepeatComponent element, int index) { 1723 if (element == null) 1724 return; 1725 Complex t; 1726 if (Utilities.noString(parentType)) 1727 t = parent; 1728 else { 1729 t = parent.predicate("fhir:"+name,index > -1); 1730 } 1731 composeElement(t, "repeat", name, element, index); 1732 if (element.hasBounds()) { 1733 composeType(t, "TimingRepeatComponent", "bounds", element.getBounds(), -1); 1734 } 1735 if (element.hasCountElement()) { 1736 composePositiveInt(t, "TimingRepeatComponent", "count", element.getCountElement(), -1); 1737 } 1738 if (element.hasCountMaxElement()) { 1739 composePositiveInt(t, "TimingRepeatComponent", "countMax", element.getCountMaxElement(), -1); 1740 } 1741 if (element.hasDurationElement()) { 1742 composeDecimal(t, "TimingRepeatComponent", "duration", element.getDurationElement(), -1); 1743 } 1744 if (element.hasDurationMaxElement()) { 1745 composeDecimal(t, "TimingRepeatComponent", "durationMax", element.getDurationMaxElement(), -1); 1746 } 1747 if (element.hasDurationUnitElement()) { 1748 composeEnum(t, "TimingRepeatComponent", "durationUnit", element.getDurationUnitElement(), -1); 1749 } 1750 if (element.hasFrequencyElement()) { 1751 composePositiveInt(t, "TimingRepeatComponent", "frequency", element.getFrequencyElement(), -1); 1752 } 1753 if (element.hasFrequencyMaxElement()) { 1754 composePositiveInt(t, "TimingRepeatComponent", "frequencyMax", element.getFrequencyMaxElement(), -1); 1755 } 1756 if (element.hasPeriodElement()) { 1757 composeDecimal(t, "TimingRepeatComponent", "period", element.getPeriodElement(), -1); 1758 } 1759 if (element.hasPeriodMaxElement()) { 1760 composeDecimal(t, "TimingRepeatComponent", "periodMax", element.getPeriodMaxElement(), -1); 1761 } 1762 if (element.hasPeriodUnitElement()) { 1763 composeEnum(t, "TimingRepeatComponent", "periodUnit", element.getPeriodUnitElement(), -1); 1764 } 1765 for (int i = 0; i < element.getDayOfWeek().size(); i++) { 1766 composeEnum(t, "TimingRepeatComponent", "dayOfWeek", element.getDayOfWeek().get(i), i); 1767 } 1768 for (int i = 0; i < element.getTimeOfDay().size(); i++) { 1769 composeTime(t, "TimingRepeatComponent", "timeOfDay", element.getTimeOfDay().get(i), i); 1770 } 1771 for (int i = 0; i < element.getWhen().size(); i++) { 1772 composeEnum(t, "TimingRepeatComponent", "when", element.getWhen().get(i), i); 1773 } 1774 if (element.hasOffsetElement()) { 1775 composeUnsignedInt(t, "TimingRepeatComponent", "offset", element.getOffsetElement(), -1); 1776 } 1777 } 1778 1779 protected void composeTriggerDefinition(Complex parent, String parentType, String name, TriggerDefinition element, int index) { 1780 if (element == null) 1781 return; 1782 Complex t; 1783 if (Utilities.noString(parentType)) 1784 t = parent; 1785 else { 1786 t = parent.predicate("fhir:"+name,index > -1); 1787 } 1788 composeDataType(t, "TriggerDefinition", name, element, index); 1789 if (element.hasTypeElement()) { 1790 composeEnum(t, "TriggerDefinition", "type", element.getTypeElement(), -1); 1791 } 1792 if (element.hasNameElement()) { 1793 composeString(t, "TriggerDefinition", "name", element.getNameElement(), -1); 1794 } 1795 if (element.hasCode()) { 1796 composeCodeableConcept(t, "TriggerDefinition", "code", element.getCode(), -1); 1797 } 1798 if (element.hasSubscriptionTopicElement()) { 1799 composeCanonical(t, "TriggerDefinition", "subscriptionTopic", element.getSubscriptionTopicElement(), -1); 1800 } 1801 if (element.hasTiming()) { 1802 composeType(t, "TriggerDefinition", "timing", element.getTiming(), -1); 1803 } 1804 for (int i = 0; i < element.getData().size(); i++) { 1805 composeDataRequirement(t, "TriggerDefinition", "data", element.getData().get(i), i); 1806 } 1807 if (element.hasCondition()) { 1808 composeExpression(t, "TriggerDefinition", "condition", element.getCondition(), -1); 1809 } 1810 } 1811 1812 protected void composeUsageContext(Complex parent, String parentType, String name, UsageContext element, int index) { 1813 if (element == null) 1814 return; 1815 Complex t; 1816 if (Utilities.noString(parentType)) 1817 t = parent; 1818 else { 1819 t = parent.predicate("fhir:"+name,index > -1); 1820 } 1821 composeDataType(t, "UsageContext", name, element, index); 1822 if (element.hasCode()) { 1823 composeCoding(t, "UsageContext", "code", element.getCode(), -1); 1824 } 1825 if (element.hasValue()) { 1826 composeType(t, "UsageContext", "value", element.getValue(), -1); 1827 } 1828 } 1829 1830 protected void composeVirtualServiceDetail(Complex parent, String parentType, String name, VirtualServiceDetail element, int index) { 1831 if (element == null) 1832 return; 1833 Complex t; 1834 if (Utilities.noString(parentType)) 1835 t = parent; 1836 else { 1837 t = parent.predicate("fhir:"+name,index > -1); 1838 } 1839 composeDataType(t, "VirtualServiceDetail", name, element, index); 1840 if (element.hasChannelType()) { 1841 composeCoding(t, "VirtualServiceDetail", "channelType", element.getChannelType(), -1); 1842 } 1843 if (element.hasAddress()) { 1844 composeType(t, "VirtualServiceDetail", "address", element.getAddress(), -1); 1845 } 1846 for (int i = 0; i < element.getAdditionalInfo().size(); i++) { 1847 composeUrl(t, "VirtualServiceDetail", "additionalInfo", element.getAdditionalInfo().get(i), i); 1848 } 1849 if (element.hasMaxParticipantsElement()) { 1850 composePositiveInt(t, "VirtualServiceDetail", "maxParticipants", element.getMaxParticipantsElement(), -1); 1851 } 1852 if (element.hasSessionKeyElement()) { 1853 composeString(t, "VirtualServiceDetail", "sessionKey", element.getSessionKeyElement(), -1); 1854 } 1855 } 1856 1857 protected void composeCanonicalResource(Complex t, String parentType, String name, CanonicalResource element, int index) { 1858 composeDomainResource(t, parentType, name, element, index); 1859 if (element.hasUrlElement()) { 1860 composeUri(t, "CanonicalResource", "url", element.getUrlElement(), -1); 1861 } 1862 for (int i = 0; i < element.getIdentifier().size(); i++) { 1863 composeIdentifier(t, "CanonicalResource", "identifier", element.getIdentifier().get(i), i); 1864 } 1865 if (element.hasVersionElement()) { 1866 composeString(t, "CanonicalResource", "version", element.getVersionElement(), -1); 1867 } 1868 if (element.hasVersionAlgorithm()) { 1869 composeType(t, "CanonicalResource", "versionAlgorithm", element.getVersionAlgorithm(), -1); 1870 } 1871 if (element.hasNameElement()) { 1872 composeString(t, "CanonicalResource", "name", element.getNameElement(), -1); 1873 } 1874 if (element.hasTitleElement()) { 1875 composeString(t, "CanonicalResource", "title", element.getTitleElement(), -1); 1876 } 1877 if (element.hasStatusElement()) { 1878 composeEnum(t, "CanonicalResource", "status", element.getStatusElement(), -1); 1879 } 1880 if (element.hasExperimentalElement()) { 1881 composeBoolean(t, "CanonicalResource", "experimental", element.getExperimentalElement(), -1); 1882 } 1883 if (element.hasDateElement()) { 1884 composeDateTime(t, "CanonicalResource", "date", element.getDateElement(), -1); 1885 } 1886 if (element.hasPublisherElement()) { 1887 composeString(t, "CanonicalResource", "publisher", element.getPublisherElement(), -1); 1888 } 1889 for (int i = 0; i < element.getContact().size(); i++) { 1890 composeContactDetail(t, "CanonicalResource", "contact", element.getContact().get(i), i); 1891 } 1892 if (element.hasDescriptionElement()) { 1893 composeMarkdown(t, "CanonicalResource", "description", element.getDescriptionElement(), -1); 1894 } 1895 for (int i = 0; i < element.getUseContext().size(); i++) { 1896 composeUsageContext(t, "CanonicalResource", "useContext", element.getUseContext().get(i), i); 1897 } 1898 for (int i = 0; i < element.getJurisdiction().size(); i++) { 1899 composeCodeableConcept(t, "CanonicalResource", "jurisdiction", element.getJurisdiction().get(i), i); 1900 } 1901 if (element.hasPurposeElement()) { 1902 composeMarkdown(t, "CanonicalResource", "purpose", element.getPurposeElement(), -1); 1903 } 1904 if (element.hasCopyrightElement()) { 1905 composeMarkdown(t, "CanonicalResource", "copyright", element.getCopyrightElement(), -1); 1906 } 1907 if (element.hasCopyrightLabelElement()) { 1908 composeString(t, "CanonicalResource", "copyrightLabel", element.getCopyrightLabelElement(), -1); 1909 } 1910 } 1911 1912 protected void composeDomainResource(Complex t, String parentType, String name, DomainResource element, int index) { 1913 composeResource(t, parentType, name, element, index); 1914 if (element.hasText()) { 1915 composeNarrative(t, "DomainResource", "text", element.getText(), -1); 1916 } 1917 for (int i = 0; i < element.getContained().size(); i++) { 1918 composeResource(t, "DomainResource", "contained", element.getContained().get(i), i); 1919 } 1920 for (int i = 0; i < element.getExtension().size(); i++) { 1921 composeExtension(t, "DomainResource", "extension", element.getExtension().get(i), i); 1922 } 1923 for (int i = 0; i < element.getModifierExtension().size(); i++) { 1924 composeExtension(t, "DomainResource", "modifierExtension", element.getModifierExtension().get(i), i); 1925 } 1926 } 1927 1928 protected void composeMetadataResource(Complex t, String parentType, String name, MetadataResource element, int index) { 1929 composeCanonicalResource(t, parentType, name, element, index); 1930 if (element.hasApprovalDateElement()) { 1931 composeDate(t, "MetadataResource", "approvalDate", element.getApprovalDateElement(), -1); 1932 } 1933 if (element.hasLastReviewDateElement()) { 1934 composeDate(t, "MetadataResource", "lastReviewDate", element.getLastReviewDateElement(), -1); 1935 } 1936 if (element.hasEffectivePeriod()) { 1937 composePeriod(t, "MetadataResource", "effectivePeriod", element.getEffectivePeriod(), -1); 1938 } 1939 for (int i = 0; i < element.getTopic().size(); i++) { 1940 composeCodeableConcept(t, "MetadataResource", "topic", element.getTopic().get(i), i); 1941 } 1942 for (int i = 0; i < element.getAuthor().size(); i++) { 1943 composeContactDetail(t, "MetadataResource", "author", element.getAuthor().get(i), i); 1944 } 1945 for (int i = 0; i < element.getEditor().size(); i++) { 1946 composeContactDetail(t, "MetadataResource", "editor", element.getEditor().get(i), i); 1947 } 1948 for (int i = 0; i < element.getReviewer().size(); i++) { 1949 composeContactDetail(t, "MetadataResource", "reviewer", element.getReviewer().get(i), i); 1950 } 1951 for (int i = 0; i < element.getEndorser().size(); i++) { 1952 composeContactDetail(t, "MetadataResource", "endorser", element.getEndorser().get(i), i); 1953 } 1954 for (int i = 0; i < element.getRelatedArtifact().size(); i++) { 1955 composeRelatedArtifact(t, "MetadataResource", "relatedArtifact", element.getRelatedArtifact().get(i), i); 1956 } 1957 } 1958 1959 protected void composeResource(Complex t, String parentType, String name, Resource element, int index) { 1960 composeBase(t, parentType, name, element, index); 1961 if (element.hasIdElement()) { 1962 composeId(t, "Resource", "id", element.getIdElement(), -1); 1963 } 1964 if (element.hasMeta()) { 1965 composeMeta(t, "Resource", "meta", element.getMeta(), -1); 1966 } 1967 if (element.hasImplicitRulesElement()) { 1968 composeUri(t, "Resource", "implicitRules", element.getImplicitRulesElement(), -1); 1969 } 1970 if (element.hasLanguageElement()) { 1971 composeCode(t, "Resource", "language", element.getLanguageElement(), -1); 1972 } 1973 } 1974 1975 protected void composeAccount(Complex parent, String parentType, String name, Account element, int index) { 1976 if (element == null) 1977 return; 1978 Complex t; 1979 if (Utilities.noString(parentType)) 1980 t = parent; 1981 else { 1982 t = parent.predicate("fhir:"+name,index > -1); 1983 } 1984 composeDomainResource(t, "Account", name, element, index); 1985 for (int i = 0; i < element.getIdentifier().size(); i++) { 1986 composeIdentifier(t, "Account", "identifier", element.getIdentifier().get(i), i); 1987 } 1988 if (element.hasStatusElement()) { 1989 composeEnum(t, "Account", "status", element.getStatusElement(), -1); 1990 } 1991 if (element.hasBillingStatus()) { 1992 composeCodeableConcept(t, "Account", "billingStatus", element.getBillingStatus(), -1); 1993 } 1994 if (element.hasType()) { 1995 composeCodeableConcept(t, "Account", "type", element.getType(), -1); 1996 } 1997 if (element.hasNameElement()) { 1998 composeString(t, "Account", "name", element.getNameElement(), -1); 1999 } 2000 for (int i = 0; i < element.getSubject().size(); i++) { 2001 composeReference(t, "Account", "subject", element.getSubject().get(i), i); 2002 } 2003 if (element.hasServicePeriod()) { 2004 composePeriod(t, "Account", "servicePeriod", element.getServicePeriod(), -1); 2005 } 2006 for (int i = 0; i < element.getCoverage().size(); i++) { 2007 composeAccountCoverageComponent(t, "Account", "coverage", element.getCoverage().get(i), i); 2008 } 2009 if (element.hasOwner()) { 2010 composeReference(t, "Account", "owner", element.getOwner(), -1); 2011 } 2012 if (element.hasDescriptionElement()) { 2013 composeMarkdown(t, "Account", "description", element.getDescriptionElement(), -1); 2014 } 2015 for (int i = 0; i < element.getGuarantor().size(); i++) { 2016 composeAccountGuarantorComponent(t, "Account", "guarantor", element.getGuarantor().get(i), i); 2017 } 2018 for (int i = 0; i < element.getDiagnosis().size(); i++) { 2019 composeAccountDiagnosisComponent(t, "Account", "diagnosis", element.getDiagnosis().get(i), i); 2020 } 2021 for (int i = 0; i < element.getProcedure().size(); i++) { 2022 composeAccountProcedureComponent(t, "Account", "procedure", element.getProcedure().get(i), i); 2023 } 2024 for (int i = 0; i < element.getRelatedAccount().size(); i++) { 2025 composeAccountRelatedAccountComponent(t, "Account", "relatedAccount", element.getRelatedAccount().get(i), i); 2026 } 2027 if (element.hasCurrency()) { 2028 composeCodeableConcept(t, "Account", "currency", element.getCurrency(), -1); 2029 } 2030 for (int i = 0; i < element.getBalance().size(); i++) { 2031 composeAccountBalanceComponent(t, "Account", "balance", element.getBalance().get(i), i); 2032 } 2033 if (element.hasCalculatedAtElement()) { 2034 composeInstant(t, "Account", "calculatedAt", element.getCalculatedAtElement(), -1); 2035 } 2036 } 2037 2038 protected void composeAccountCoverageComponent(Complex parent, String parentType, String name, Account.CoverageComponent element, int index) { 2039 if (element == null) 2040 return; 2041 Complex t; 2042 if (Utilities.noString(parentType)) 2043 t = parent; 2044 else { 2045 t = parent.predicate("fhir:"+name,index > -1); 2046 } 2047 composeBackboneElement(t, "coverage", name, element, index); 2048 if (element.hasCoverage()) { 2049 composeReference(t, "CoverageComponent", "coverage", element.getCoverage(), -1); 2050 } 2051 if (element.hasPriorityElement()) { 2052 composePositiveInt(t, "CoverageComponent", "priority", element.getPriorityElement(), -1); 2053 } 2054 } 2055 2056 protected void composeAccountGuarantorComponent(Complex parent, String parentType, String name, Account.GuarantorComponent element, int index) { 2057 if (element == null) 2058 return; 2059 Complex t; 2060 if (Utilities.noString(parentType)) 2061 t = parent; 2062 else { 2063 t = parent.predicate("fhir:"+name,index > -1); 2064 } 2065 composeBackboneElement(t, "guarantor", name, element, index); 2066 if (element.hasParty()) { 2067 composeReference(t, "GuarantorComponent", "party", element.getParty(), -1); 2068 } 2069 if (element.hasOnHoldElement()) { 2070 composeBoolean(t, "GuarantorComponent", "onHold", element.getOnHoldElement(), -1); 2071 } 2072 if (element.hasPeriod()) { 2073 composePeriod(t, "GuarantorComponent", "period", element.getPeriod(), -1); 2074 } 2075 } 2076 2077 protected void composeAccountDiagnosisComponent(Complex parent, String parentType, String name, Account.AccountDiagnosisComponent element, int index) { 2078 if (element == null) 2079 return; 2080 Complex t; 2081 if (Utilities.noString(parentType)) 2082 t = parent; 2083 else { 2084 t = parent.predicate("fhir:"+name,index > -1); 2085 } 2086 composeBackboneElement(t, "diagnosis", name, element, index); 2087 if (element.hasSequenceElement()) { 2088 composePositiveInt(t, "AccountDiagnosisComponent", "sequence", element.getSequenceElement(), -1); 2089 } 2090 if (element.hasCondition()) { 2091 composeCodeableReference(t, "AccountDiagnosisComponent", "condition", element.getCondition(), -1); 2092 } 2093 if (element.hasDateOfDiagnosisElement()) { 2094 composeDateTime(t, "AccountDiagnosisComponent", "dateOfDiagnosis", element.getDateOfDiagnosisElement(), -1); 2095 } 2096 for (int i = 0; i < element.getType().size(); i++) { 2097 composeCodeableConcept(t, "AccountDiagnosisComponent", "type", element.getType().get(i), i); 2098 } 2099 if (element.hasOnAdmissionElement()) { 2100 composeBoolean(t, "AccountDiagnosisComponent", "onAdmission", element.getOnAdmissionElement(), -1); 2101 } 2102 for (int i = 0; i < element.getPackageCode().size(); i++) { 2103 composeCodeableConcept(t, "AccountDiagnosisComponent", "packageCode", element.getPackageCode().get(i), i); 2104 } 2105 } 2106 2107 protected void composeAccountProcedureComponent(Complex parent, String parentType, String name, Account.AccountProcedureComponent element, int index) { 2108 if (element == null) 2109 return; 2110 Complex t; 2111 if (Utilities.noString(parentType)) 2112 t = parent; 2113 else { 2114 t = parent.predicate("fhir:"+name,index > -1); 2115 } 2116 composeBackboneElement(t, "procedure", name, element, index); 2117 if (element.hasSequenceElement()) { 2118 composePositiveInt(t, "AccountProcedureComponent", "sequence", element.getSequenceElement(), -1); 2119 } 2120 if (element.hasCode()) { 2121 composeCodeableReference(t, "AccountProcedureComponent", "code", element.getCode(), -1); 2122 } 2123 if (element.hasDateOfServiceElement()) { 2124 composeDateTime(t, "AccountProcedureComponent", "dateOfService", element.getDateOfServiceElement(), -1); 2125 } 2126 for (int i = 0; i < element.getType().size(); i++) { 2127 composeCodeableConcept(t, "AccountProcedureComponent", "type", element.getType().get(i), i); 2128 } 2129 for (int i = 0; i < element.getPackageCode().size(); i++) { 2130 composeCodeableConcept(t, "AccountProcedureComponent", "packageCode", element.getPackageCode().get(i), i); 2131 } 2132 for (int i = 0; i < element.getDevice().size(); i++) { 2133 composeReference(t, "AccountProcedureComponent", "device", element.getDevice().get(i), i); 2134 } 2135 } 2136 2137 protected void composeAccountRelatedAccountComponent(Complex parent, String parentType, String name, Account.AccountRelatedAccountComponent element, int index) { 2138 if (element == null) 2139 return; 2140 Complex t; 2141 if (Utilities.noString(parentType)) 2142 t = parent; 2143 else { 2144 t = parent.predicate("fhir:"+name,index > -1); 2145 } 2146 composeBackboneElement(t, "relatedAccount", name, element, index); 2147 if (element.hasRelationship()) { 2148 composeCodeableConcept(t, "AccountRelatedAccountComponent", "relationship", element.getRelationship(), -1); 2149 } 2150 if (element.hasAccount()) { 2151 composeReference(t, "AccountRelatedAccountComponent", "account", element.getAccount(), -1); 2152 } 2153 } 2154 2155 protected void composeAccountBalanceComponent(Complex parent, String parentType, String name, Account.AccountBalanceComponent element, int index) { 2156 if (element == null) 2157 return; 2158 Complex t; 2159 if (Utilities.noString(parentType)) 2160 t = parent; 2161 else { 2162 t = parent.predicate("fhir:"+name,index > -1); 2163 } 2164 composeBackboneElement(t, "balance", name, element, index); 2165 if (element.hasAggregate()) { 2166 composeCodeableConcept(t, "AccountBalanceComponent", "aggregate", element.getAggregate(), -1); 2167 } 2168 if (element.hasTerm()) { 2169 composeCodeableConcept(t, "AccountBalanceComponent", "term", element.getTerm(), -1); 2170 } 2171 if (element.hasEstimateElement()) { 2172 composeBoolean(t, "AccountBalanceComponent", "estimate", element.getEstimateElement(), -1); 2173 } 2174 if (element.hasAmount()) { 2175 composeMoney(t, "AccountBalanceComponent", "amount", element.getAmount(), -1); 2176 } 2177 } 2178 2179 protected void composeActivityDefinition(Complex parent, String parentType, String name, ActivityDefinition element, int index) { 2180 if (element == null) 2181 return; 2182 Complex t; 2183 if (Utilities.noString(parentType)) 2184 t = parent; 2185 else { 2186 t = parent.predicate("fhir:"+name,index > -1); 2187 } 2188 composeMetadataResource(t, "ActivityDefinition", name, element, index); 2189 if (element.hasUrlElement()) { 2190 composeUri(t, "ActivityDefinition", "url", element.getUrlElement(), -1); 2191 } 2192 for (int i = 0; i < element.getIdentifier().size(); i++) { 2193 composeIdentifier(t, "ActivityDefinition", "identifier", element.getIdentifier().get(i), i); 2194 } 2195 if (element.hasVersionElement()) { 2196 composeString(t, "ActivityDefinition", "version", element.getVersionElement(), -1); 2197 } 2198 if (element.hasVersionAlgorithm()) { 2199 composeType(t, "ActivityDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1); 2200 } 2201 if (element.hasNameElement()) { 2202 composeString(t, "ActivityDefinition", "name", element.getNameElement(), -1); 2203 } 2204 if (element.hasTitleElement()) { 2205 composeString(t, "ActivityDefinition", "title", element.getTitleElement(), -1); 2206 } 2207 if (element.hasSubtitleElement()) { 2208 composeString(t, "ActivityDefinition", "subtitle", element.getSubtitleElement(), -1); 2209 } 2210 if (element.hasStatusElement()) { 2211 composeEnum(t, "ActivityDefinition", "status", element.getStatusElement(), -1); 2212 } 2213 if (element.hasExperimentalElement()) { 2214 composeBoolean(t, "ActivityDefinition", "experimental", element.getExperimentalElement(), -1); 2215 } 2216 if (element.hasSubject()) { 2217 composeType(t, "ActivityDefinition", "subject", element.getSubject(), -1); 2218 } 2219 if (element.hasDateElement()) { 2220 composeDateTime(t, "ActivityDefinition", "date", element.getDateElement(), -1); 2221 } 2222 if (element.hasPublisherElement()) { 2223 composeString(t, "ActivityDefinition", "publisher", element.getPublisherElement(), -1); 2224 } 2225 for (int i = 0; i < element.getContact().size(); i++) { 2226 composeContactDetail(t, "ActivityDefinition", "contact", element.getContact().get(i), i); 2227 } 2228 if (element.hasDescriptionElement()) { 2229 composeMarkdown(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1); 2230 } 2231 for (int i = 0; i < element.getUseContext().size(); i++) { 2232 composeUsageContext(t, "ActivityDefinition", "useContext", element.getUseContext().get(i), i); 2233 } 2234 for (int i = 0; i < element.getJurisdiction().size(); i++) { 2235 composeCodeableConcept(t, "ActivityDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 2236 } 2237 if (element.hasPurposeElement()) { 2238 composeMarkdown(t, "ActivityDefinition", "purpose", element.getPurposeElement(), -1); 2239 } 2240 if (element.hasUsageElement()) { 2241 composeMarkdown(t, "ActivityDefinition", "usage", element.getUsageElement(), -1); 2242 } 2243 if (element.hasCopyrightElement()) { 2244 composeMarkdown(t, "ActivityDefinition", "copyright", element.getCopyrightElement(), -1); 2245 } 2246 if (element.hasCopyrightLabelElement()) { 2247 composeString(t, "ActivityDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1); 2248 } 2249 if (element.hasApprovalDateElement()) { 2250 composeDate(t, "ActivityDefinition", "approvalDate", element.getApprovalDateElement(), -1); 2251 } 2252 if (element.hasLastReviewDateElement()) { 2253 composeDate(t, "ActivityDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 2254 } 2255 if (element.hasEffectivePeriod()) { 2256 composePeriod(t, "ActivityDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 2257 } 2258 for (int i = 0; i < element.getTopic().size(); i++) { 2259 composeCodeableConcept(t, "ActivityDefinition", "topic", element.getTopic().get(i), i); 2260 } 2261 for (int i = 0; i < element.getAuthor().size(); i++) { 2262 composeContactDetail(t, "ActivityDefinition", "author", element.getAuthor().get(i), i); 2263 } 2264 for (int i = 0; i < element.getEditor().size(); i++) { 2265 composeContactDetail(t, "ActivityDefinition", "editor", element.getEditor().get(i), i); 2266 } 2267 for (int i = 0; i < element.getReviewer().size(); i++) { 2268 composeContactDetail(t, "ActivityDefinition", "reviewer", element.getReviewer().get(i), i); 2269 } 2270 for (int i = 0; i < element.getEndorser().size(); i++) { 2271 composeContactDetail(t, "ActivityDefinition", "endorser", element.getEndorser().get(i), i); 2272 } 2273 for (int i = 0; i < element.getRelatedArtifact().size(); i++) { 2274 composeRelatedArtifact(t, "ActivityDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 2275 } 2276 for (int i = 0; i < element.getLibrary().size(); i++) { 2277 composeCanonical(t, "ActivityDefinition", "library", element.getLibrary().get(i), i); 2278 } 2279 if (element.hasKindElement()) { 2280 composeEnum(t, "ActivityDefinition", "kind", element.getKindElement(), -1); 2281 } 2282 if (element.hasProfileElement()) { 2283 composeCanonical(t, "ActivityDefinition", "profile", element.getProfileElement(), -1); 2284 } 2285 if (element.hasCode()) { 2286 composeCodeableConcept(t, "ActivityDefinition", "code", element.getCode(), -1); 2287 } 2288 if (element.hasIntentElement()) { 2289 composeEnum(t, "ActivityDefinition", "intent", element.getIntentElement(), -1); 2290 } 2291 if (element.hasPriorityElement()) { 2292 composeEnum(t, "ActivityDefinition", "priority", element.getPriorityElement(), -1); 2293 } 2294 if (element.hasDoNotPerformElement()) { 2295 composeBoolean(t, "ActivityDefinition", "doNotPerform", element.getDoNotPerformElement(), -1); 2296 } 2297 if (element.hasTiming()) { 2298 composeType(t, "ActivityDefinition", "timing", element.getTiming(), -1); 2299 } 2300 if (element.hasAsNeeded()) { 2301 composeType(t, "ActivityDefinition", "asNeeded", element.getAsNeeded(), -1); 2302 } 2303 if (element.hasLocation()) { 2304 composeCodeableReference(t, "ActivityDefinition", "location", element.getLocation(), -1); 2305 } 2306 for (int i = 0; i < element.getParticipant().size(); i++) { 2307 composeActivityDefinitionParticipantComponent(t, "ActivityDefinition", "participant", element.getParticipant().get(i), i); 2308 } 2309 if (element.hasProduct()) { 2310 composeType(t, "ActivityDefinition", "product", element.getProduct(), -1); 2311 } 2312 if (element.hasQuantity()) { 2313 composeQuantity(t, "ActivityDefinition", "quantity", element.getQuantity(), -1); 2314 } 2315 for (int i = 0; i < element.getDosage().size(); i++) { 2316 composeDosage(t, "ActivityDefinition", "dosage", element.getDosage().get(i), i); 2317 } 2318 for (int i = 0; i < element.getBodySite().size(); i++) { 2319 composeCodeableConcept(t, "ActivityDefinition", "bodySite", element.getBodySite().get(i), i); 2320 } 2321 for (int i = 0; i < element.getSpecimenRequirement().size(); i++) { 2322 composeCanonical(t, "ActivityDefinition", "specimenRequirement", element.getSpecimenRequirement().get(i), i); 2323 } 2324 for (int i = 0; i < element.getObservationRequirement().size(); i++) { 2325 composeCanonical(t, "ActivityDefinition", "observationRequirement", element.getObservationRequirement().get(i), i); 2326 } 2327 for (int i = 0; i < element.getObservationResultRequirement().size(); i++) { 2328 composeCanonical(t, "ActivityDefinition", "observationResultRequirement", element.getObservationResultRequirement().get(i), i); 2329 } 2330 if (element.hasTransformElement()) { 2331 composeCanonical(t, "ActivityDefinition", "transform", element.getTransformElement(), -1); 2332 } 2333 for (int i = 0; i < element.getDynamicValue().size(); i++) { 2334 composeActivityDefinitionDynamicValueComponent(t, "ActivityDefinition", "dynamicValue", element.getDynamicValue().get(i), i); 2335 } 2336 } 2337 2338 protected void composeActivityDefinitionParticipantComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionParticipantComponent element, int index) { 2339 if (element == null) 2340 return; 2341 Complex t; 2342 if (Utilities.noString(parentType)) 2343 t = parent; 2344 else { 2345 t = parent.predicate("fhir:"+name,index > -1); 2346 } 2347 composeBackboneElement(t, "participant", name, element, index); 2348 if (element.hasTypeElement()) { 2349 composeEnum(t, "ActivityDefinitionParticipantComponent", "type", element.getTypeElement(), -1); 2350 } 2351 if (element.hasTypeCanonicalElement()) { 2352 composeCanonical(t, "ActivityDefinitionParticipantComponent", "typeCanonical", element.getTypeCanonicalElement(), -1); 2353 } 2354 if (element.hasTypeReference()) { 2355 composeReference(t, "ActivityDefinitionParticipantComponent", "typeReference", element.getTypeReference(), -1); 2356 } 2357 if (element.hasRole()) { 2358 composeCodeableConcept(t, "ActivityDefinitionParticipantComponent", "role", element.getRole(), -1); 2359 } 2360 if (element.hasFunction()) { 2361 composeCodeableConcept(t, "ActivityDefinitionParticipantComponent", "function", element.getFunction(), -1); 2362 } 2363 } 2364 2365 protected void composeActivityDefinitionDynamicValueComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionDynamicValueComponent element, int index) { 2366 if (element == null) 2367 return; 2368 Complex t; 2369 if (Utilities.noString(parentType)) 2370 t = parent; 2371 else { 2372 t = parent.predicate("fhir:"+name,index > -1); 2373 } 2374 composeBackboneElement(t, "dynamicValue", name, element, index); 2375 if (element.hasPathElement()) { 2376 composeString(t, "ActivityDefinitionDynamicValueComponent", "path", element.getPathElement(), -1); 2377 } 2378 if (element.hasExpression()) { 2379 composeExpression(t, "ActivityDefinitionDynamicValueComponent", "expression", element.getExpression(), -1); 2380 } 2381 } 2382 2383 protected void composeActorDefinition(Complex parent, String parentType, String name, ActorDefinition element, int index) { 2384 if (element == null) 2385 return; 2386 Complex t; 2387 if (Utilities.noString(parentType)) 2388 t = parent; 2389 else { 2390 t = parent.predicate("fhir:"+name,index > -1); 2391 } 2392 composeCanonicalResource(t, "ActorDefinition", name, element, index); 2393 if (element.hasUrlElement()) { 2394 composeUri(t, "ActorDefinition", "url", element.getUrlElement(), -1); 2395 } 2396 for (int i = 0; i < element.getIdentifier().size(); i++) { 2397 composeIdentifier(t, "ActorDefinition", "identifier", element.getIdentifier().get(i), i); 2398 } 2399 if (element.hasVersionElement()) { 2400 composeString(t, "ActorDefinition", "version", element.getVersionElement(), -1); 2401 } 2402 if (element.hasVersionAlgorithm()) { 2403 composeType(t, "ActorDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1); 2404 } 2405 if (element.hasNameElement()) { 2406 composeString(t, "ActorDefinition", "name", element.getNameElement(), -1); 2407 } 2408 if (element.hasTitleElement()) { 2409 composeString(t, "ActorDefinition", "title", element.getTitleElement(), -1); 2410 } 2411 if (element.hasStatusElement()) { 2412 composeEnum(t, "ActorDefinition", "status", element.getStatusElement(), -1); 2413 } 2414 if (element.hasExperimentalElement()) { 2415 composeBoolean(t, "ActorDefinition", "experimental", element.getExperimentalElement(), -1); 2416 } 2417 if (element.hasDateElement()) { 2418 composeDateTime(t, "ActorDefinition", "date", element.getDateElement(), -1); 2419 } 2420 if (element.hasPublisherElement()) { 2421 composeString(t, "ActorDefinition", "publisher", element.getPublisherElement(), -1); 2422 } 2423 for (int i = 0; i < element.getContact().size(); i++) { 2424 composeContactDetail(t, "ActorDefinition", "contact", element.getContact().get(i), i); 2425 } 2426 if (element.hasDescriptionElement()) { 2427 composeMarkdown(t, "ActorDefinition", "description", element.getDescriptionElement(), -1); 2428 } 2429 for (int i = 0; i < element.getUseContext().size(); i++) { 2430 composeUsageContext(t, "ActorDefinition", "useContext", element.getUseContext().get(i), i); 2431 } 2432 for (int i = 0; i < element.getJurisdiction().size(); i++) { 2433 composeCodeableConcept(t, "ActorDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 2434 } 2435 if (element.hasPurposeElement()) { 2436 composeMarkdown(t, "ActorDefinition", "purpose", element.getPurposeElement(), -1); 2437 } 2438 if (element.hasCopyrightElement()) { 2439 composeMarkdown(t, "ActorDefinition", "copyright", element.getCopyrightElement(), -1); 2440 } 2441 if (element.hasCopyrightLabelElement()) { 2442 composeString(t, "ActorDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1); 2443 } 2444 if (element.hasTypeElement()) { 2445 composeEnum(t, "ActorDefinition", "type", element.getTypeElement(), -1); 2446 } 2447 if (element.hasDocumentationElement()) { 2448 composeMarkdown(t, "ActorDefinition", "documentation", element.getDocumentationElement(), -1); 2449 } 2450 for (int i = 0; i < element.getReference().size(); i++) { 2451 composeUrl(t, "ActorDefinition", "reference", element.getReference().get(i), i); 2452 } 2453 if (element.hasCapabilitiesElement()) { 2454 composeCanonical(t, "ActorDefinition", "capabilities", element.getCapabilitiesElement(), -1); 2455 } 2456 for (int i = 0; i < element.getDerivedFrom().size(); i++) { 2457 composeCanonical(t, "ActorDefinition", "derivedFrom", element.getDerivedFrom().get(i), i); 2458 } 2459 } 2460 2461 protected void composeAdministrableProductDefinition(Complex parent, String parentType, String name, AdministrableProductDefinition element, int index) { 2462 if (element == null) 2463 return; 2464 Complex t; 2465 if (Utilities.noString(parentType)) 2466 t = parent; 2467 else { 2468 t = parent.predicate("fhir:"+name,index > -1); 2469 } 2470 composeDomainResource(t, "AdministrableProductDefinition", name, element, index); 2471 for (int i = 0; i < element.getIdentifier().size(); i++) { 2472 composeIdentifier(t, "AdministrableProductDefinition", "identifier", element.getIdentifier().get(i), i); 2473 } 2474 if (element.hasStatusElement()) { 2475 composeEnum(t, "AdministrableProductDefinition", "status", element.getStatusElement(), -1); 2476 } 2477 for (int i = 0; i < element.getFormOf().size(); i++) { 2478 composeReference(t, "AdministrableProductDefinition", "formOf", element.getFormOf().get(i), i); 2479 } 2480 if (element.hasAdministrableDoseForm()) { 2481 composeCodeableConcept(t, "AdministrableProductDefinition", "administrableDoseForm", element.getAdministrableDoseForm(), -1); 2482 } 2483 if (element.hasUnitOfPresentation()) { 2484 composeCodeableConcept(t, "AdministrableProductDefinition", "unitOfPresentation", element.getUnitOfPresentation(), -1); 2485 } 2486 for (int i = 0; i < element.getProducedFrom().size(); i++) { 2487 composeReference(t, "AdministrableProductDefinition", "producedFrom", element.getProducedFrom().get(i), i); 2488 } 2489 for (int i = 0; i < element.getIngredient().size(); i++) { 2490 composeCodeableConcept(t, "AdministrableProductDefinition", "ingredient", element.getIngredient().get(i), i); 2491 } 2492 if (element.hasDevice()) { 2493 composeReference(t, "AdministrableProductDefinition", "device", element.getDevice(), -1); 2494 } 2495 if (element.hasDescriptionElement()) { 2496 composeMarkdown(t, "AdministrableProductDefinition", "description", element.getDescriptionElement(), -1); 2497 } 2498 for (int i = 0; i < element.getProperty().size(); i++) { 2499 composeAdministrableProductDefinitionPropertyComponent(t, "AdministrableProductDefinition", "property", element.getProperty().get(i), i); 2500 } 2501 for (int i = 0; i < element.getRouteOfAdministration().size(); i++) { 2502 composeAdministrableProductDefinitionRouteOfAdministrationComponent(t, "AdministrableProductDefinition", "routeOfAdministration", element.getRouteOfAdministration().get(i), i); 2503 } 2504 } 2505 2506 protected void composeAdministrableProductDefinitionPropertyComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionPropertyComponent element, int index) { 2507 if (element == null) 2508 return; 2509 Complex t; 2510 if (Utilities.noString(parentType)) 2511 t = parent; 2512 else { 2513 t = parent.predicate("fhir:"+name,index > -1); 2514 } 2515 composeBackboneElement(t, "property", name, element, index); 2516 if (element.hasType()) { 2517 composeCodeableConcept(t, "AdministrableProductDefinitionPropertyComponent", "type", element.getType(), -1); 2518 } 2519 if (element.hasValue()) { 2520 composeType(t, "AdministrableProductDefinitionPropertyComponent", "value", element.getValue(), -1); 2521 } 2522 if (element.hasStatus()) { 2523 composeCodeableConcept(t, "AdministrableProductDefinitionPropertyComponent", "status", element.getStatus(), -1); 2524 } 2525 } 2526 2527 protected void composeAdministrableProductDefinitionRouteOfAdministrationComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationComponent element, int index) { 2528 if (element == null) 2529 return; 2530 Complex t; 2531 if (Utilities.noString(parentType)) 2532 t = parent; 2533 else { 2534 t = parent.predicate("fhir:"+name,index > -1); 2535 } 2536 composeBackboneElement(t, "routeOfAdministration", name, element, index); 2537 if (element.hasCode()) { 2538 composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "code", element.getCode(), -1); 2539 } 2540 if (element.hasFirstDose()) { 2541 composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "firstDose", element.getFirstDose(), -1); 2542 } 2543 if (element.hasMaxSingleDose()) { 2544 composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxSingleDose", element.getMaxSingleDose(), -1); 2545 } 2546 if (element.hasMaxDosePerDay()) { 2547 composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxDosePerDay", element.getMaxDosePerDay(), -1); 2548 } 2549 if (element.hasMaxDosePerTreatmentPeriod()) { 2550 composeRatio(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxDosePerTreatmentPeriod", element.getMaxDosePerTreatmentPeriod(), -1); 2551 } 2552 if (element.hasMaxTreatmentPeriod()) { 2553 composeDuration(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "maxTreatmentPeriod", element.getMaxTreatmentPeriod(), -1); 2554 } 2555 for (int i = 0; i < element.getTargetSpecies().size(); i++) { 2556 composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent(t, "AdministrableProductDefinitionRouteOfAdministrationComponent", "targetSpecies", element.getTargetSpecies().get(i), i); 2557 } 2558 } 2559 2560 protected void composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent element, int index) { 2561 if (element == null) 2562 return; 2563 Complex t; 2564 if (Utilities.noString(parentType)) 2565 t = parent; 2566 else { 2567 t = parent.predicate("fhir:"+name,index > -1); 2568 } 2569 composeBackboneElement(t, "targetSpecies", name, element, index); 2570 if (element.hasCode()) { 2571 composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent", "code", element.getCode(), -1); 2572 } 2573 for (int i = 0; i < element.getWithdrawalPeriod().size(); i++) { 2574 composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesComponent", "withdrawalPeriod", element.getWithdrawalPeriod().get(i), i); 2575 } 2576 } 2577 2578 protected void composeAdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent(Complex parent, String parentType, String name, AdministrableProductDefinition.AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent element, int index) { 2579 if (element == null) 2580 return; 2581 Complex t; 2582 if (Utilities.noString(parentType)) 2583 t = parent; 2584 else { 2585 t = parent.predicate("fhir:"+name,index > -1); 2586 } 2587 composeBackboneElement(t, "withdrawalPeriod", name, element, index); 2588 if (element.hasTissue()) { 2589 composeCodeableConcept(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "tissue", element.getTissue(), -1); 2590 } 2591 if (element.hasValue()) { 2592 composeQuantity(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "value", element.getValue(), -1); 2593 } 2594 if (element.hasSupportingInformationElement()) { 2595 composeString(t, "AdministrableProductDefinitionRouteOfAdministrationTargetSpeciesWithdrawalPeriodComponent", "supportingInformation", element.getSupportingInformationElement(), -1); 2596 } 2597 } 2598 2599 protected void composeAdverseEvent(Complex parent, String parentType, String name, AdverseEvent element, int index) { 2600 if (element == null) 2601 return; 2602 Complex t; 2603 if (Utilities.noString(parentType)) 2604 t = parent; 2605 else { 2606 t = parent.predicate("fhir:"+name,index > -1); 2607 } 2608 composeDomainResource(t, "AdverseEvent", name, element, index); 2609 for (int i = 0; i < element.getIdentifier().size(); i++) { 2610 composeIdentifier(t, "AdverseEvent", "identifier", element.getIdentifier().get(i), i); 2611 } 2612 if (element.hasStatusElement()) { 2613 composeEnum(t, "AdverseEvent", "status", element.getStatusElement(), -1); 2614 } 2615 if (element.hasActualityElement()) { 2616 composeEnum(t, "AdverseEvent", "actuality", element.getActualityElement(), -1); 2617 } 2618 for (int i = 0; i < element.getCategory().size(); i++) { 2619 composeCodeableConcept(t, "AdverseEvent", "category", element.getCategory().get(i), i); 2620 } 2621 if (element.hasCode()) { 2622 composeCodeableConcept(t, "AdverseEvent", "code", element.getCode(), -1); 2623 } 2624 if (element.hasSubject()) { 2625 composeReference(t, "AdverseEvent", "subject", element.getSubject(), -1); 2626 } 2627 if (element.hasEncounter()) { 2628 composeReference(t, "AdverseEvent", "encounter", element.getEncounter(), -1); 2629 } 2630 if (element.hasOccurrence()) { 2631 composeType(t, "AdverseEvent", "occurrence", element.getOccurrence(), -1); 2632 } 2633 if (element.hasDetectedElement()) { 2634 composeDateTime(t, "AdverseEvent", "detected", element.getDetectedElement(), -1); 2635 } 2636 if (element.hasRecordedDateElement()) { 2637 composeDateTime(t, "AdverseEvent", "recordedDate", element.getRecordedDateElement(), -1); 2638 } 2639 for (int i = 0; i < element.getResultingEffect().size(); i++) { 2640 composeReference(t, "AdverseEvent", "resultingEffect", element.getResultingEffect().get(i), i); 2641 } 2642 if (element.hasLocation()) { 2643 composeReference(t, "AdverseEvent", "location", element.getLocation(), -1); 2644 } 2645 if (element.hasSeriousness()) { 2646 composeCodeableConcept(t, "AdverseEvent", "seriousness", element.getSeriousness(), -1); 2647 } 2648 for (int i = 0; i < element.getOutcome().size(); i++) { 2649 composeCodeableConcept(t, "AdverseEvent", "outcome", element.getOutcome().get(i), i); 2650 } 2651 if (element.hasRecorder()) { 2652 composeReference(t, "AdverseEvent", "recorder", element.getRecorder(), -1); 2653 } 2654 for (int i = 0; i < element.getParticipant().size(); i++) { 2655 composeAdverseEventParticipantComponent(t, "AdverseEvent", "participant", element.getParticipant().get(i), i); 2656 } 2657 for (int i = 0; i < element.getStudy().size(); i++) { 2658 composeReference(t, "AdverseEvent", "study", element.getStudy().get(i), i); 2659 } 2660 if (element.hasExpectedInResearchStudyElement()) { 2661 composeBoolean(t, "AdverseEvent", "expectedInResearchStudy", element.getExpectedInResearchStudyElement(), -1); 2662 } 2663 for (int i = 0; i < element.getSuspectEntity().size(); i++) { 2664 composeAdverseEventSuspectEntityComponent(t, "AdverseEvent", "suspectEntity", element.getSuspectEntity().get(i), i); 2665 } 2666 for (int i = 0; i < element.getContributingFactor().size(); i++) { 2667 composeAdverseEventContributingFactorComponent(t, "AdverseEvent", "contributingFactor", element.getContributingFactor().get(i), i); 2668 } 2669 for (int i = 0; i < element.getPreventiveAction().size(); i++) { 2670 composeAdverseEventPreventiveActionComponent(t, "AdverseEvent", "preventiveAction", element.getPreventiveAction().get(i), i); 2671 } 2672 for (int i = 0; i < element.getMitigatingAction().size(); i++) { 2673 composeAdverseEventMitigatingActionComponent(t, "AdverseEvent", "mitigatingAction", element.getMitigatingAction().get(i), i); 2674 } 2675 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 2676 composeAdverseEventSupportingInfoComponent(t, "AdverseEvent", "supportingInfo", element.getSupportingInfo().get(i), i); 2677 } 2678 for (int i = 0; i < element.getNote().size(); i++) { 2679 composeAnnotation(t, "AdverseEvent", "note", element.getNote().get(i), i); 2680 } 2681 } 2682 2683 protected void composeAdverseEventParticipantComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventParticipantComponent element, int index) { 2684 if (element == null) 2685 return; 2686 Complex t; 2687 if (Utilities.noString(parentType)) 2688 t = parent; 2689 else { 2690 t = parent.predicate("fhir:"+name,index > -1); 2691 } 2692 composeBackboneElement(t, "participant", name, element, index); 2693 if (element.hasFunction()) { 2694 composeCodeableConcept(t, "AdverseEventParticipantComponent", "function", element.getFunction(), -1); 2695 } 2696 if (element.hasActor()) { 2697 composeReference(t, "AdverseEventParticipantComponent", "actor", element.getActor(), -1); 2698 } 2699 } 2700 2701 protected void composeAdverseEventSuspectEntityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityComponent element, int index) { 2702 if (element == null) 2703 return; 2704 Complex t; 2705 if (Utilities.noString(parentType)) 2706 t = parent; 2707 else { 2708 t = parent.predicate("fhir:"+name,index > -1); 2709 } 2710 composeBackboneElement(t, "suspectEntity", name, element, index); 2711 if (element.hasInstance()) { 2712 composeType(t, "AdverseEventSuspectEntityComponent", "instance", element.getInstance(), -1); 2713 } 2714 if (element.hasCausality()) { 2715 composeAdverseEventSuspectEntityCausalityComponent(t, "AdverseEventSuspectEntityComponent", "causality", element.getCausality(), -1); 2716 } 2717 } 2718 2719 protected void composeAdverseEventSuspectEntityCausalityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityCausalityComponent element, int index) { 2720 if (element == null) 2721 return; 2722 Complex t; 2723 if (Utilities.noString(parentType)) 2724 t = parent; 2725 else { 2726 t = parent.predicate("fhir:"+name,index > -1); 2727 } 2728 composeBackboneElement(t, "causality", name, element, index); 2729 if (element.hasAssessmentMethod()) { 2730 composeCodeableConcept(t, "AdverseEventSuspectEntityCausalityComponent", "assessmentMethod", element.getAssessmentMethod(), -1); 2731 } 2732 if (element.hasEntityRelatedness()) { 2733 composeCodeableConcept(t, "AdverseEventSuspectEntityCausalityComponent", "entityRelatedness", element.getEntityRelatedness(), -1); 2734 } 2735 if (element.hasAuthor()) { 2736 composeReference(t, "AdverseEventSuspectEntityCausalityComponent", "author", element.getAuthor(), -1); 2737 } 2738 } 2739 2740 protected void composeAdverseEventContributingFactorComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventContributingFactorComponent element, int index) { 2741 if (element == null) 2742 return; 2743 Complex t; 2744 if (Utilities.noString(parentType)) 2745 t = parent; 2746 else { 2747 t = parent.predicate("fhir:"+name,index > -1); 2748 } 2749 composeBackboneElement(t, "contributingFactor", name, element, index); 2750 if (element.hasItem()) { 2751 composeType(t, "AdverseEventContributingFactorComponent", "item", element.getItem(), -1); 2752 } 2753 } 2754 2755 protected void composeAdverseEventPreventiveActionComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventPreventiveActionComponent element, int index) { 2756 if (element == null) 2757 return; 2758 Complex t; 2759 if (Utilities.noString(parentType)) 2760 t = parent; 2761 else { 2762 t = parent.predicate("fhir:"+name,index > -1); 2763 } 2764 composeBackboneElement(t, "preventiveAction", name, element, index); 2765 if (element.hasItem()) { 2766 composeType(t, "AdverseEventPreventiveActionComponent", "item", element.getItem(), -1); 2767 } 2768 } 2769 2770 protected void composeAdverseEventMitigatingActionComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventMitigatingActionComponent element, int index) { 2771 if (element == null) 2772 return; 2773 Complex t; 2774 if (Utilities.noString(parentType)) 2775 t = parent; 2776 else { 2777 t = parent.predicate("fhir:"+name,index > -1); 2778 } 2779 composeBackboneElement(t, "mitigatingAction", name, element, index); 2780 if (element.hasItem()) { 2781 composeType(t, "AdverseEventMitigatingActionComponent", "item", element.getItem(), -1); 2782 } 2783 } 2784 2785 protected void composeAdverseEventSupportingInfoComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSupportingInfoComponent element, int index) { 2786 if (element == null) 2787 return; 2788 Complex t; 2789 if (Utilities.noString(parentType)) 2790 t = parent; 2791 else { 2792 t = parent.predicate("fhir:"+name,index > -1); 2793 } 2794 composeBackboneElement(t, "supportingInfo", name, element, index); 2795 if (element.hasItem()) { 2796 composeType(t, "AdverseEventSupportingInfoComponent", "item", element.getItem(), -1); 2797 } 2798 } 2799 2800 protected void composeAllergyIntolerance(Complex parent, String parentType, String name, AllergyIntolerance element, int index) { 2801 if (element == null) 2802 return; 2803 Complex t; 2804 if (Utilities.noString(parentType)) 2805 t = parent; 2806 else { 2807 t = parent.predicate("fhir:"+name,index > -1); 2808 } 2809 composeDomainResource(t, "AllergyIntolerance", name, element, index); 2810 for (int i = 0; i < element.getIdentifier().size(); i++) { 2811 composeIdentifier(t, "AllergyIntolerance", "identifier", element.getIdentifier().get(i), i); 2812 } 2813 if (element.hasClinicalStatus()) { 2814 composeCodeableConcept(t, "AllergyIntolerance", "clinicalStatus", element.getClinicalStatus(), -1); 2815 } 2816 if (element.hasVerificationStatus()) { 2817 composeCodeableConcept(t, "AllergyIntolerance", "verificationStatus", element.getVerificationStatus(), -1); 2818 } 2819 if (element.hasType()) { 2820 composeCodeableConcept(t, "AllergyIntolerance", "type", element.getType(), -1); 2821 } 2822 for (int i = 0; i < element.getCategory().size(); i++) { 2823 composeEnum(t, "AllergyIntolerance", "category", element.getCategory().get(i), i); 2824 } 2825 if (element.hasCriticalityElement()) { 2826 composeEnum(t, "AllergyIntolerance", "criticality", element.getCriticalityElement(), -1); 2827 } 2828 if (element.hasCode()) { 2829 composeCodeableConcept(t, "AllergyIntolerance", "code", element.getCode(), -1); 2830 } 2831 if (element.hasPatient()) { 2832 composeReference(t, "AllergyIntolerance", "patient", element.getPatient(), -1); 2833 } 2834 if (element.hasEncounter()) { 2835 composeReference(t, "AllergyIntolerance", "encounter", element.getEncounter(), -1); 2836 } 2837 if (element.hasOnset()) { 2838 composeType(t, "AllergyIntolerance", "onset", element.getOnset(), -1); 2839 } 2840 if (element.hasRecordedDateElement()) { 2841 composeDateTime(t, "AllergyIntolerance", "recordedDate", element.getRecordedDateElement(), -1); 2842 } 2843 for (int i = 0; i < element.getParticipant().size(); i++) { 2844 composeAllergyIntoleranceParticipantComponent(t, "AllergyIntolerance", "participant", element.getParticipant().get(i), i); 2845 } 2846 if (element.hasLastOccurrenceElement()) { 2847 composeDateTime(t, "AllergyIntolerance", "lastOccurrence", element.getLastOccurrenceElement(), -1); 2848 } 2849 for (int i = 0; i < element.getNote().size(); i++) { 2850 composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i); 2851 } 2852 for (int i = 0; i < element.getReaction().size(); i++) { 2853 composeAllergyIntoleranceReactionComponent(t, "AllergyIntolerance", "reaction", element.getReaction().get(i), i); 2854 } 2855 } 2856 2857 protected void composeAllergyIntoleranceParticipantComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceParticipantComponent element, int index) { 2858 if (element == null) 2859 return; 2860 Complex t; 2861 if (Utilities.noString(parentType)) 2862 t = parent; 2863 else { 2864 t = parent.predicate("fhir:"+name,index > -1); 2865 } 2866 composeBackboneElement(t, "participant", name, element, index); 2867 if (element.hasFunction()) { 2868 composeCodeableConcept(t, "AllergyIntoleranceParticipantComponent", "function", element.getFunction(), -1); 2869 } 2870 if (element.hasActor()) { 2871 composeReference(t, "AllergyIntoleranceParticipantComponent", "actor", element.getActor(), -1); 2872 } 2873 } 2874 2875 protected void composeAllergyIntoleranceReactionComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceReactionComponent element, int index) { 2876 if (element == null) 2877 return; 2878 Complex t; 2879 if (Utilities.noString(parentType)) 2880 t = parent; 2881 else { 2882 t = parent.predicate("fhir:"+name,index > -1); 2883 } 2884 composeBackboneElement(t, "reaction", name, element, index); 2885 if (element.hasSubstance()) { 2886 composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "substance", element.getSubstance(), -1); 2887 } 2888 for (int i = 0; i < element.getManifestation().size(); i++) { 2889 composeCodeableReference(t, "AllergyIntoleranceReactionComponent", "manifestation", element.getManifestation().get(i), i); 2890 } 2891 if (element.hasDescriptionElement()) { 2892 composeString(t, "AllergyIntoleranceReactionComponent", "description", element.getDescriptionElement(), -1); 2893 } 2894 if (element.hasOnsetElement()) { 2895 composeDateTime(t, "AllergyIntoleranceReactionComponent", "onset", element.getOnsetElement(), -1); 2896 } 2897 if (element.hasSeverityElement()) { 2898 composeEnum(t, "AllergyIntoleranceReactionComponent", "severity", element.getSeverityElement(), -1); 2899 } 2900 if (element.hasExposureRoute()) { 2901 composeCodeableConcept(t, "AllergyIntoleranceReactionComponent", "exposureRoute", element.getExposureRoute(), -1); 2902 } 2903 for (int i = 0; i < element.getNote().size(); i++) { 2904 composeAnnotation(t, "AllergyIntoleranceReactionComponent", "note", element.getNote().get(i), i); 2905 } 2906 } 2907 2908 protected void composeAppointment(Complex parent, String parentType, String name, Appointment element, int index) { 2909 if (element == null) 2910 return; 2911 Complex t; 2912 if (Utilities.noString(parentType)) 2913 t = parent; 2914 else { 2915 t = parent.predicate("fhir:"+name,index > -1); 2916 } 2917 composeDomainResource(t, "Appointment", name, element, index); 2918 for (int i = 0; i < element.getIdentifier().size(); i++) { 2919 composeIdentifier(t, "Appointment", "identifier", element.getIdentifier().get(i), i); 2920 } 2921 if (element.hasStatusElement()) { 2922 composeEnum(t, "Appointment", "status", element.getStatusElement(), -1); 2923 } 2924 if (element.hasCancellationReason()) { 2925 composeCodeableConcept(t, "Appointment", "cancellationReason", element.getCancellationReason(), -1); 2926 } 2927 for (int i = 0; i < element.getClass_().size(); i++) { 2928 composeCodeableConcept(t, "Appointment", "class", element.getClass_().get(i), i); 2929 } 2930 for (int i = 0; i < element.getServiceCategory().size(); i++) { 2931 composeCodeableConcept(t, "Appointment", "serviceCategory", element.getServiceCategory().get(i), i); 2932 } 2933 for (int i = 0; i < element.getServiceType().size(); i++) { 2934 composeCodeableReference(t, "Appointment", "serviceType", element.getServiceType().get(i), i); 2935 } 2936 for (int i = 0; i < element.getSpecialty().size(); i++) { 2937 composeCodeableConcept(t, "Appointment", "specialty", element.getSpecialty().get(i), i); 2938 } 2939 if (element.hasAppointmentType()) { 2940 composeCodeableConcept(t, "Appointment", "appointmentType", element.getAppointmentType(), -1); 2941 } 2942 for (int i = 0; i < element.getReason().size(); i++) { 2943 composeCodeableReference(t, "Appointment", "reason", element.getReason().get(i), i); 2944 } 2945 if (element.hasPriority()) { 2946 composeCodeableConcept(t, "Appointment", "priority", element.getPriority(), -1); 2947 } 2948 if (element.hasDescriptionElement()) { 2949 composeString(t, "Appointment", "description", element.getDescriptionElement(), -1); 2950 } 2951 for (int i = 0; i < element.getReplaces().size(); i++) { 2952 composeReference(t, "Appointment", "replaces", element.getReplaces().get(i), i); 2953 } 2954 for (int i = 0; i < element.getVirtualService().size(); i++) { 2955 composeVirtualServiceDetail(t, "Appointment", "virtualService", element.getVirtualService().get(i), i); 2956 } 2957 for (int i = 0; i < element.getSupportingInformation().size(); i++) { 2958 composeReference(t, "Appointment", "supportingInformation", element.getSupportingInformation().get(i), i); 2959 } 2960 if (element.hasPreviousAppointment()) { 2961 composeReference(t, "Appointment", "previousAppointment", element.getPreviousAppointment(), -1); 2962 } 2963 if (element.hasOriginatingAppointment()) { 2964 composeReference(t, "Appointment", "originatingAppointment", element.getOriginatingAppointment(), -1); 2965 } 2966 if (element.hasStartElement()) { 2967 composeInstant(t, "Appointment", "start", element.getStartElement(), -1); 2968 } 2969 if (element.hasEndElement()) { 2970 composeInstant(t, "Appointment", "end", element.getEndElement(), -1); 2971 } 2972 if (element.hasMinutesDurationElement()) { 2973 composePositiveInt(t, "Appointment", "minutesDuration", element.getMinutesDurationElement(), -1); 2974 } 2975 for (int i = 0; i < element.getRequestedPeriod().size(); i++) { 2976 composePeriod(t, "Appointment", "requestedPeriod", element.getRequestedPeriod().get(i), i); 2977 } 2978 for (int i = 0; i < element.getSlot().size(); i++) { 2979 composeReference(t, "Appointment", "slot", element.getSlot().get(i), i); 2980 } 2981 for (int i = 0; i < element.getAccount().size(); i++) { 2982 composeReference(t, "Appointment", "account", element.getAccount().get(i), i); 2983 } 2984 if (element.hasCreatedElement()) { 2985 composeDateTime(t, "Appointment", "created", element.getCreatedElement(), -1); 2986 } 2987 if (element.hasCancellationDateElement()) { 2988 composeDateTime(t, "Appointment", "cancellationDate", element.getCancellationDateElement(), -1); 2989 } 2990 for (int i = 0; i < element.getNote().size(); i++) { 2991 composeAnnotation(t, "Appointment", "note", element.getNote().get(i), i); 2992 } 2993 for (int i = 0; i < element.getPatientInstruction().size(); i++) { 2994 composeCodeableReference(t, "Appointment", "patientInstruction", element.getPatientInstruction().get(i), i); 2995 } 2996 for (int i = 0; i < element.getBasedOn().size(); i++) { 2997 composeReference(t, "Appointment", "basedOn", element.getBasedOn().get(i), i); 2998 } 2999 if (element.hasSubject()) { 3000 composeReference(t, "Appointment", "subject", element.getSubject(), -1); 3001 } 3002 for (int i = 0; i < element.getParticipant().size(); i++) { 3003 composeAppointmentParticipantComponent(t, "Appointment", "participant", element.getParticipant().get(i), i); 3004 } 3005 if (element.hasRecurrenceIdElement()) { 3006 composePositiveInt(t, "Appointment", "recurrenceId", element.getRecurrenceIdElement(), -1); 3007 } 3008 if (element.hasOccurrenceChangedElement()) { 3009 composeBoolean(t, "Appointment", "occurrenceChanged", element.getOccurrenceChangedElement(), -1); 3010 } 3011 for (int i = 0; i < element.getRecurrenceTemplate().size(); i++) { 3012 composeAppointmentRecurrenceTemplateComponent(t, "Appointment", "recurrenceTemplate", element.getRecurrenceTemplate().get(i), i); 3013 } 3014 } 3015 3016 protected void composeAppointmentParticipantComponent(Complex parent, String parentType, String name, Appointment.AppointmentParticipantComponent element, int index) { 3017 if (element == null) 3018 return; 3019 Complex t; 3020 if (Utilities.noString(parentType)) 3021 t = parent; 3022 else { 3023 t = parent.predicate("fhir:"+name,index > -1); 3024 } 3025 composeBackboneElement(t, "participant", name, element, index); 3026 for (int i = 0; i < element.getType().size(); i++) { 3027 composeCodeableConcept(t, "AppointmentParticipantComponent", "type", element.getType().get(i), i); 3028 } 3029 if (element.hasPeriod()) { 3030 composePeriod(t, "AppointmentParticipantComponent", "period", element.getPeriod(), -1); 3031 } 3032 if (element.hasActor()) { 3033 composeReference(t, "AppointmentParticipantComponent", "actor", element.getActor(), -1); 3034 } 3035 if (element.hasRequiredElement()) { 3036 composeBoolean(t, "AppointmentParticipantComponent", "required", element.getRequiredElement(), -1); 3037 } 3038 if (element.hasStatusElement()) { 3039 composeEnum(t, "AppointmentParticipantComponent", "status", element.getStatusElement(), -1); 3040 } 3041 } 3042 3043 protected void composeAppointmentRecurrenceTemplateComponent(Complex parent, String parentType, String name, Appointment.AppointmentRecurrenceTemplateComponent element, int index) { 3044 if (element == null) 3045 return; 3046 Complex t; 3047 if (Utilities.noString(parentType)) 3048 t = parent; 3049 else { 3050 t = parent.predicate("fhir:"+name,index > -1); 3051 } 3052 composeBackboneElement(t, "recurrenceTemplate", name, element, index); 3053 if (element.hasTimezone()) { 3054 composeCodeableConcept(t, "AppointmentRecurrenceTemplateComponent", "timezone", element.getTimezone(), -1); 3055 } 3056 if (element.hasRecurrenceType()) { 3057 composeCodeableConcept(t, "AppointmentRecurrenceTemplateComponent", "recurrenceType", element.getRecurrenceType(), -1); 3058 } 3059 if (element.hasLastOccurrenceDateElement()) { 3060 composeDate(t, "AppointmentRecurrenceTemplateComponent", "lastOccurrenceDate", element.getLastOccurrenceDateElement(), -1); 3061 } 3062 if (element.hasOccurrenceCountElement()) { 3063 composePositiveInt(t, "AppointmentRecurrenceTemplateComponent", "occurrenceCount", element.getOccurrenceCountElement(), -1); 3064 } 3065 for (int i = 0; i < element.getOccurrenceDate().size(); i++) { 3066 composeDate(t, "AppointmentRecurrenceTemplateComponent", "occurrenceDate", element.getOccurrenceDate().get(i), i); 3067 } 3068 if (element.hasWeeklyTemplate()) { 3069 composeAppointmentRecurrenceTemplateWeeklyTemplateComponent(t, "AppointmentRecurrenceTemplateComponent", "weeklyTemplate", element.getWeeklyTemplate(), -1); 3070 } 3071 if (element.hasMonthlyTemplate()) { 3072 composeAppointmentRecurrenceTemplateMonthlyTemplateComponent(t, "AppointmentRecurrenceTemplateComponent", "monthlyTemplate", element.getMonthlyTemplate(), -1); 3073 } 3074 if (element.hasYearlyTemplate()) { 3075 composeAppointmentRecurrenceTemplateYearlyTemplateComponent(t, "AppointmentRecurrenceTemplateComponent", "yearlyTemplate", element.getYearlyTemplate(), -1); 3076 } 3077 for (int i = 0; i < element.getExcludingDate().size(); i++) { 3078 composeDate(t, "AppointmentRecurrenceTemplateComponent", "excludingDate", element.getExcludingDate().get(i), i); 3079 } 3080 for (int i = 0; i < element.getExcludingRecurrenceId().size(); i++) { 3081 composePositiveInt(t, "AppointmentRecurrenceTemplateComponent", "excludingRecurrenceId", element.getExcludingRecurrenceId().get(i), i); 3082 } 3083 } 3084 3085 protected void composeAppointmentRecurrenceTemplateWeeklyTemplateComponent(Complex parent, String parentType, String name, Appointment.AppointmentRecurrenceTemplateWeeklyTemplateComponent element, int index) { 3086 if (element == null) 3087 return; 3088 Complex t; 3089 if (Utilities.noString(parentType)) 3090 t = parent; 3091 else { 3092 t = parent.predicate("fhir:"+name,index > -1); 3093 } 3094 composeBackboneElement(t, "weeklyTemplate", name, element, index); 3095 if (element.hasMondayElement()) { 3096 composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "monday", element.getMondayElement(), -1); 3097 } 3098 if (element.hasTuesdayElement()) { 3099 composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "tuesday", element.getTuesdayElement(), -1); 3100 } 3101 if (element.hasWednesdayElement()) { 3102 composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "wednesday", element.getWednesdayElement(), -1); 3103 } 3104 if (element.hasThursdayElement()) { 3105 composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "thursday", element.getThursdayElement(), -1); 3106 } 3107 if (element.hasFridayElement()) { 3108 composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "friday", element.getFridayElement(), -1); 3109 } 3110 if (element.hasSaturdayElement()) { 3111 composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "saturday", element.getSaturdayElement(), -1); 3112 } 3113 if (element.hasSundayElement()) { 3114 composeBoolean(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "sunday", element.getSundayElement(), -1); 3115 } 3116 if (element.hasWeekIntervalElement()) { 3117 composePositiveInt(t, "AppointmentRecurrenceTemplateWeeklyTemplateComponent", "weekInterval", element.getWeekIntervalElement(), -1); 3118 } 3119 } 3120 3121 protected void composeAppointmentRecurrenceTemplateMonthlyTemplateComponent(Complex parent, String parentType, String name, Appointment.AppointmentRecurrenceTemplateMonthlyTemplateComponent element, int index) { 3122 if (element == null) 3123 return; 3124 Complex t; 3125 if (Utilities.noString(parentType)) 3126 t = parent; 3127 else { 3128 t = parent.predicate("fhir:"+name,index > -1); 3129 } 3130 composeBackboneElement(t, "monthlyTemplate", name, element, index); 3131 if (element.hasDayOfMonthElement()) { 3132 composePositiveInt(t, "AppointmentRecurrenceTemplateMonthlyTemplateComponent", "dayOfMonth", element.getDayOfMonthElement(), -1); 3133 } 3134 if (element.hasNthWeekOfMonth()) { 3135 composeCoding(t, "AppointmentRecurrenceTemplateMonthlyTemplateComponent", "nthWeekOfMonth", element.getNthWeekOfMonth(), -1); 3136 } 3137 if (element.hasDayOfWeek()) { 3138 composeCoding(t, "AppointmentRecurrenceTemplateMonthlyTemplateComponent", "dayOfWeek", element.getDayOfWeek(), -1); 3139 } 3140 if (element.hasMonthIntervalElement()) { 3141 composePositiveInt(t, "AppointmentRecurrenceTemplateMonthlyTemplateComponent", "monthInterval", element.getMonthIntervalElement(), -1); 3142 } 3143 } 3144 3145 protected void composeAppointmentRecurrenceTemplateYearlyTemplateComponent(Complex parent, String parentType, String name, Appointment.AppointmentRecurrenceTemplateYearlyTemplateComponent element, int index) { 3146 if (element == null) 3147 return; 3148 Complex t; 3149 if (Utilities.noString(parentType)) 3150 t = parent; 3151 else { 3152 t = parent.predicate("fhir:"+name,index > -1); 3153 } 3154 composeBackboneElement(t, "yearlyTemplate", name, element, index); 3155 if (element.hasYearIntervalElement()) { 3156 composePositiveInt(t, "AppointmentRecurrenceTemplateYearlyTemplateComponent", "yearInterval", element.getYearIntervalElement(), -1); 3157 } 3158 } 3159 3160 protected void composeAppointmentResponse(Complex parent, String parentType, String name, AppointmentResponse element, int index) { 3161 if (element == null) 3162 return; 3163 Complex t; 3164 if (Utilities.noString(parentType)) 3165 t = parent; 3166 else { 3167 t = parent.predicate("fhir:"+name,index > -1); 3168 } 3169 composeDomainResource(t, "AppointmentResponse", name, element, index); 3170 for (int i = 0; i < element.getIdentifier().size(); i++) { 3171 composeIdentifier(t, "AppointmentResponse", "identifier", element.getIdentifier().get(i), i); 3172 } 3173 if (element.hasAppointment()) { 3174 composeReference(t, "AppointmentResponse", "appointment", element.getAppointment(), -1); 3175 } 3176 if (element.hasProposedNewTimeElement()) { 3177 composeBoolean(t, "AppointmentResponse", "proposedNewTime", element.getProposedNewTimeElement(), -1); 3178 } 3179 if (element.hasStartElement()) { 3180 composeInstant(t, "AppointmentResponse", "start", element.getStartElement(), -1); 3181 } 3182 if (element.hasEndElement()) { 3183 composeInstant(t, "AppointmentResponse", "end", element.getEndElement(), -1); 3184 } 3185 for (int i = 0; i < element.getParticipantType().size(); i++) { 3186 composeCodeableConcept(t, "AppointmentResponse", "participantType", element.getParticipantType().get(i), i); 3187 } 3188 if (element.hasActor()) { 3189 composeReference(t, "AppointmentResponse", "actor", element.getActor(), -1); 3190 } 3191 if (element.hasParticipantStatusElement()) { 3192 composeEnum(t, "AppointmentResponse", "participantStatus", element.getParticipantStatusElement(), -1); 3193 } 3194 if (element.hasCommentElement()) { 3195 composeMarkdown(t, "AppointmentResponse", "comment", element.getCommentElement(), -1); 3196 } 3197 if (element.hasRecurringElement()) { 3198 composeBoolean(t, "AppointmentResponse", "recurring", element.getRecurringElement(), -1); 3199 } 3200 if (element.hasOccurrenceDateElement()) { 3201 composeDate(t, "AppointmentResponse", "occurrenceDate", element.getOccurrenceDateElement(), -1); 3202 } 3203 if (element.hasRecurrenceIdElement()) { 3204 composePositiveInt(t, "AppointmentResponse", "recurrenceId", element.getRecurrenceIdElement(), -1); 3205 } 3206 } 3207 3208 protected void composeArtifactAssessment(Complex parent, String parentType, String name, ArtifactAssessment element, int index) { 3209 if (element == null) 3210 return; 3211 Complex t; 3212 if (Utilities.noString(parentType)) 3213 t = parent; 3214 else { 3215 t = parent.predicate("fhir:"+name,index > -1); 3216 } 3217 composeDomainResource(t, "ArtifactAssessment", name, element, index); 3218 for (int i = 0; i < element.getIdentifier().size(); i++) { 3219 composeIdentifier(t, "ArtifactAssessment", "identifier", element.getIdentifier().get(i), i); 3220 } 3221 if (element.hasTitleElement()) { 3222 composeString(t, "ArtifactAssessment", "title", element.getTitleElement(), -1); 3223 } 3224 if (element.hasCiteAs()) { 3225 composeType(t, "ArtifactAssessment", "citeAs", element.getCiteAs(), -1); 3226 } 3227 if (element.hasDateElement()) { 3228 composeDateTime(t, "ArtifactAssessment", "date", element.getDateElement(), -1); 3229 } 3230 if (element.hasCopyrightElement()) { 3231 composeMarkdown(t, "ArtifactAssessment", "copyright", element.getCopyrightElement(), -1); 3232 } 3233 if (element.hasApprovalDateElement()) { 3234 composeDate(t, "ArtifactAssessment", "approvalDate", element.getApprovalDateElement(), -1); 3235 } 3236 if (element.hasLastReviewDateElement()) { 3237 composeDate(t, "ArtifactAssessment", "lastReviewDate", element.getLastReviewDateElement(), -1); 3238 } 3239 if (element.hasArtifact()) { 3240 composeType(t, "ArtifactAssessment", "artifact", element.getArtifact(), -1); 3241 } 3242 for (int i = 0; i < element.getContent().size(); i++) { 3243 composeArtifactAssessmentContentComponent(t, "ArtifactAssessment", "content", element.getContent().get(i), i); 3244 } 3245 if (element.hasWorkflowStatusElement()) { 3246 composeEnum(t, "ArtifactAssessment", "workflowStatus", element.getWorkflowStatusElement(), -1); 3247 } 3248 if (element.hasDispositionElement()) { 3249 composeEnum(t, "ArtifactAssessment", "disposition", element.getDispositionElement(), -1); 3250 } 3251 } 3252 3253 protected void composeArtifactAssessmentContentComponent(Complex parent, String parentType, String name, ArtifactAssessment.ArtifactAssessmentContentComponent element, int index) { 3254 if (element == null) 3255 return; 3256 Complex t; 3257 if (Utilities.noString(parentType)) 3258 t = parent; 3259 else { 3260 t = parent.predicate("fhir:"+name,index > -1); 3261 } 3262 composeBackboneElement(t, "content", name, element, index); 3263 if (element.hasInformationTypeElement()) { 3264 composeEnum(t, "ArtifactAssessmentContentComponent", "informationType", element.getInformationTypeElement(), -1); 3265 } 3266 if (element.hasSummaryElement()) { 3267 composeMarkdown(t, "ArtifactAssessmentContentComponent", "summary", element.getSummaryElement(), -1); 3268 } 3269 if (element.hasType()) { 3270 composeCodeableConcept(t, "ArtifactAssessmentContentComponent", "type", element.getType(), -1); 3271 } 3272 for (int i = 0; i < element.getClassifier().size(); i++) { 3273 composeCodeableConcept(t, "ArtifactAssessmentContentComponent", "classifier", element.getClassifier().get(i), i); 3274 } 3275 if (element.hasQuantity()) { 3276 composeQuantity(t, "ArtifactAssessmentContentComponent", "quantity", element.getQuantity(), -1); 3277 } 3278 if (element.hasAuthor()) { 3279 composeReference(t, "ArtifactAssessmentContentComponent", "author", element.getAuthor(), -1); 3280 } 3281 for (int i = 0; i < element.getPath().size(); i++) { 3282 composeUri(t, "ArtifactAssessmentContentComponent", "path", element.getPath().get(i), i); 3283 } 3284 for (int i = 0; i < element.getRelatedArtifact().size(); i++) { 3285 composeRelatedArtifact(t, "ArtifactAssessmentContentComponent", "relatedArtifact", element.getRelatedArtifact().get(i), i); 3286 } 3287 if (element.hasFreeToShareElement()) { 3288 composeBoolean(t, "ArtifactAssessmentContentComponent", "freeToShare", element.getFreeToShareElement(), -1); 3289 } 3290 for (int i = 0; i < element.getComponent().size(); i++) { 3291 composeArtifactAssessmentContentComponent(t, "ArtifactAssessmentContentComponent", "component", element.getComponent().get(i), i); 3292 } 3293 } 3294 3295 protected void composeAuditEvent(Complex parent, String parentType, String name, AuditEvent element, int index) { 3296 if (element == null) 3297 return; 3298 Complex t; 3299 if (Utilities.noString(parentType)) 3300 t = parent; 3301 else { 3302 t = parent.predicate("fhir:"+name,index > -1); 3303 } 3304 composeDomainResource(t, "AuditEvent", name, element, index); 3305 for (int i = 0; i < element.getCategory().size(); i++) { 3306 composeCodeableConcept(t, "AuditEvent", "category", element.getCategory().get(i), i); 3307 } 3308 if (element.hasCode()) { 3309 composeCodeableConcept(t, "AuditEvent", "code", element.getCode(), -1); 3310 } 3311 if (element.hasActionElement()) { 3312 composeEnum(t, "AuditEvent", "action", element.getActionElement(), -1); 3313 } 3314 if (element.hasSeverityElement()) { 3315 composeEnum(t, "AuditEvent", "severity", element.getSeverityElement(), -1); 3316 } 3317 if (element.hasOccurred()) { 3318 composeType(t, "AuditEvent", "occurred", element.getOccurred(), -1); 3319 } 3320 if (element.hasRecordedElement()) { 3321 composeInstant(t, "AuditEvent", "recorded", element.getRecordedElement(), -1); 3322 } 3323 if (element.hasOutcome()) { 3324 composeAuditEventOutcomeComponent(t, "AuditEvent", "outcome", element.getOutcome(), -1); 3325 } 3326 for (int i = 0; i < element.getAuthorization().size(); i++) { 3327 composeCodeableConcept(t, "AuditEvent", "authorization", element.getAuthorization().get(i), i); 3328 } 3329 for (int i = 0; i < element.getBasedOn().size(); i++) { 3330 composeReference(t, "AuditEvent", "basedOn", element.getBasedOn().get(i), i); 3331 } 3332 if (element.hasPatient()) { 3333 composeReference(t, "AuditEvent", "patient", element.getPatient(), -1); 3334 } 3335 if (element.hasEncounter()) { 3336 composeReference(t, "AuditEvent", "encounter", element.getEncounter(), -1); 3337 } 3338 for (int i = 0; i < element.getAgent().size(); i++) { 3339 composeAuditEventAgentComponent(t, "AuditEvent", "agent", element.getAgent().get(i), i); 3340 } 3341 if (element.hasSource()) { 3342 composeAuditEventSourceComponent(t, "AuditEvent", "source", element.getSource(), -1); 3343 } 3344 for (int i = 0; i < element.getEntity().size(); i++) { 3345 composeAuditEventEntityComponent(t, "AuditEvent", "entity", element.getEntity().get(i), i); 3346 } 3347 } 3348 3349 protected void composeAuditEventOutcomeComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventOutcomeComponent element, int index) { 3350 if (element == null) 3351 return; 3352 Complex t; 3353 if (Utilities.noString(parentType)) 3354 t = parent; 3355 else { 3356 t = parent.predicate("fhir:"+name,index > -1); 3357 } 3358 composeBackboneElement(t, "outcome", name, element, index); 3359 if (element.hasCode()) { 3360 composeCoding(t, "AuditEventOutcomeComponent", "code", element.getCode(), -1); 3361 } 3362 for (int i = 0; i < element.getDetail().size(); i++) { 3363 composeCodeableConcept(t, "AuditEventOutcomeComponent", "detail", element.getDetail().get(i), i); 3364 } 3365 } 3366 3367 protected void composeAuditEventAgentComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentComponent element, int index) { 3368 if (element == null) 3369 return; 3370 Complex t; 3371 if (Utilities.noString(parentType)) 3372 t = parent; 3373 else { 3374 t = parent.predicate("fhir:"+name,index > -1); 3375 } 3376 composeBackboneElement(t, "agent", name, element, index); 3377 if (element.hasType()) { 3378 composeCodeableConcept(t, "AuditEventAgentComponent", "type", element.getType(), -1); 3379 } 3380 for (int i = 0; i < element.getRole().size(); i++) { 3381 composeCodeableConcept(t, "AuditEventAgentComponent", "role", element.getRole().get(i), i); 3382 } 3383 if (element.hasWho()) { 3384 composeReference(t, "AuditEventAgentComponent", "who", element.getWho(), -1); 3385 } 3386 if (element.hasRequestorElement()) { 3387 composeBoolean(t, "AuditEventAgentComponent", "requestor", element.getRequestorElement(), -1); 3388 } 3389 if (element.hasLocation()) { 3390 composeReference(t, "AuditEventAgentComponent", "location", element.getLocation(), -1); 3391 } 3392 for (int i = 0; i < element.getPolicy().size(); i++) { 3393 composeUri(t, "AuditEventAgentComponent", "policy", element.getPolicy().get(i), i); 3394 } 3395 if (element.hasNetwork()) { 3396 composeType(t, "AuditEventAgentComponent", "network", element.getNetwork(), -1); 3397 } 3398 for (int i = 0; i < element.getAuthorization().size(); i++) { 3399 composeCodeableConcept(t, "AuditEventAgentComponent", "authorization", element.getAuthorization().get(i), i); 3400 } 3401 } 3402 3403 protected void composeAuditEventSourceComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventSourceComponent element, int index) { 3404 if (element == null) 3405 return; 3406 Complex t; 3407 if (Utilities.noString(parentType)) 3408 t = parent; 3409 else { 3410 t = parent.predicate("fhir:"+name,index > -1); 3411 } 3412 composeBackboneElement(t, "source", name, element, index); 3413 if (element.hasSite()) { 3414 composeReference(t, "AuditEventSourceComponent", "site", element.getSite(), -1); 3415 } 3416 if (element.hasObserver()) { 3417 composeReference(t, "AuditEventSourceComponent", "observer", element.getObserver(), -1); 3418 } 3419 for (int i = 0; i < element.getType().size(); i++) { 3420 composeCodeableConcept(t, "AuditEventSourceComponent", "type", element.getType().get(i), i); 3421 } 3422 } 3423 3424 protected void composeAuditEventEntityComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityComponent element, int index) { 3425 if (element == null) 3426 return; 3427 Complex t; 3428 if (Utilities.noString(parentType)) 3429 t = parent; 3430 else { 3431 t = parent.predicate("fhir:"+name,index > -1); 3432 } 3433 composeBackboneElement(t, "entity", name, element, index); 3434 if (element.hasWhat()) { 3435 composeReference(t, "AuditEventEntityComponent", "what", element.getWhat(), -1); 3436 } 3437 if (element.hasRole()) { 3438 composeCodeableConcept(t, "AuditEventEntityComponent", "role", element.getRole(), -1); 3439 } 3440 for (int i = 0; i < element.getSecurityLabel().size(); i++) { 3441 composeCodeableConcept(t, "AuditEventEntityComponent", "securityLabel", element.getSecurityLabel().get(i), i); 3442 } 3443 if (element.hasQueryElement()) { 3444 composeBase64Binary(t, "AuditEventEntityComponent", "query", element.getQueryElement(), -1); 3445 } 3446 for (int i = 0; i < element.getDetail().size(); i++) { 3447 composeAuditEventEntityDetailComponent(t, "AuditEventEntityComponent", "detail", element.getDetail().get(i), i); 3448 } 3449 for (int i = 0; i < element.getAgent().size(); i++) { 3450 composeAuditEventAgentComponent(t, "AuditEventEntityComponent", "agent", element.getAgent().get(i), i); 3451 } 3452 } 3453 3454 protected void composeAuditEventEntityDetailComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityDetailComponent element, int index) { 3455 if (element == null) 3456 return; 3457 Complex t; 3458 if (Utilities.noString(parentType)) 3459 t = parent; 3460 else { 3461 t = parent.predicate("fhir:"+name,index > -1); 3462 } 3463 composeBackboneElement(t, "detail", name, element, index); 3464 if (element.hasType()) { 3465 composeCodeableConcept(t, "AuditEventEntityDetailComponent", "type", element.getType(), -1); 3466 } 3467 if (element.hasValue()) { 3468 composeType(t, "AuditEventEntityDetailComponent", "value", element.getValue(), -1); 3469 } 3470 } 3471 3472 protected void composeBasic(Complex parent, String parentType, String name, Basic element, int index) { 3473 if (element == null) 3474 return; 3475 Complex t; 3476 if (Utilities.noString(parentType)) 3477 t = parent; 3478 else { 3479 t = parent.predicate("fhir:"+name,index > -1); 3480 } 3481 composeDomainResource(t, "Basic", name, element, index); 3482 for (int i = 0; i < element.getIdentifier().size(); i++) { 3483 composeIdentifier(t, "Basic", "identifier", element.getIdentifier().get(i), i); 3484 } 3485 if (element.hasCode()) { 3486 composeCodeableConcept(t, "Basic", "code", element.getCode(), -1); 3487 } 3488 if (element.hasSubject()) { 3489 composeReference(t, "Basic", "subject", element.getSubject(), -1); 3490 } 3491 if (element.hasCreatedElement()) { 3492 composeDateTime(t, "Basic", "created", element.getCreatedElement(), -1); 3493 } 3494 if (element.hasAuthor()) { 3495 composeReference(t, "Basic", "author", element.getAuthor(), -1); 3496 } 3497 } 3498 3499 protected void composeBinary(Complex parent, String parentType, String name, Binary element, int index) { 3500 if (element == null) 3501 return; 3502 Complex t; 3503 if (Utilities.noString(parentType)) 3504 t = parent; 3505 else { 3506 t = parent.predicate("fhir:"+name,index > -1); 3507 } 3508 composeResource(t, "Binary", name, element, index); 3509 if (element.hasContentTypeElement()) { 3510 composeCode(t, "Binary", "contentType", element.getContentTypeElement(), -1); 3511 } 3512 if (element.hasSecurityContext()) { 3513 composeReference(t, "Binary", "securityContext", element.getSecurityContext(), -1); 3514 } 3515 if (element.hasDataElement()) { 3516 composeBase64Binary(t, "Binary", "data", element.getDataElement(), -1); 3517 } 3518 } 3519 3520 protected void composeBiologicallyDerivedProduct(Complex parent, String parentType, String name, BiologicallyDerivedProduct element, int index) { 3521 if (element == null) 3522 return; 3523 Complex t; 3524 if (Utilities.noString(parentType)) 3525 t = parent; 3526 else { 3527 t = parent.predicate("fhir:"+name,index > -1); 3528 } 3529 composeDomainResource(t, "BiologicallyDerivedProduct", name, element, index); 3530 if (element.hasProductCategory()) { 3531 composeCoding(t, "BiologicallyDerivedProduct", "productCategory", element.getProductCategory(), -1); 3532 } 3533 if (element.hasProductCode()) { 3534 composeCodeableConcept(t, "BiologicallyDerivedProduct", "productCode", element.getProductCode(), -1); 3535 } 3536 for (int i = 0; i < element.getParent().size(); i++) { 3537 composeReference(t, "BiologicallyDerivedProduct", "parent", element.getParent().get(i), i); 3538 } 3539 for (int i = 0; i < element.getRequest().size(); i++) { 3540 composeReference(t, "BiologicallyDerivedProduct", "request", element.getRequest().get(i), i); 3541 } 3542 for (int i = 0; i < element.getIdentifier().size(); i++) { 3543 composeIdentifier(t, "BiologicallyDerivedProduct", "identifier", element.getIdentifier().get(i), i); 3544 } 3545 if (element.hasBiologicalSourceEvent()) { 3546 composeIdentifier(t, "BiologicallyDerivedProduct", "biologicalSourceEvent", element.getBiologicalSourceEvent(), -1); 3547 } 3548 for (int i = 0; i < element.getProcessingFacility().size(); i++) { 3549 composeReference(t, "BiologicallyDerivedProduct", "processingFacility", element.getProcessingFacility().get(i), i); 3550 } 3551 if (element.hasDivisionElement()) { 3552 composeString(t, "BiologicallyDerivedProduct", "division", element.getDivisionElement(), -1); 3553 } 3554 if (element.hasProductStatus()) { 3555 composeCoding(t, "BiologicallyDerivedProduct", "productStatus", element.getProductStatus(), -1); 3556 } 3557 if (element.hasExpirationDateElement()) { 3558 composeDateTime(t, "BiologicallyDerivedProduct", "expirationDate", element.getExpirationDateElement(), -1); 3559 } 3560 if (element.hasCollection()) { 3561 composeBiologicallyDerivedProductCollectionComponent(t, "BiologicallyDerivedProduct", "collection", element.getCollection(), -1); 3562 } 3563 if (element.hasStorageTempRequirements()) { 3564 composeRange(t, "BiologicallyDerivedProduct", "storageTempRequirements", element.getStorageTempRequirements(), -1); 3565 } 3566 for (int i = 0; i < element.getProperty().size(); i++) { 3567 composeBiologicallyDerivedProductPropertyComponent(t, "BiologicallyDerivedProduct", "property", element.getProperty().get(i), i); 3568 } 3569 } 3570 3571 protected void composeBiologicallyDerivedProductCollectionComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductCollectionComponent element, int index) { 3572 if (element == null) 3573 return; 3574 Complex t; 3575 if (Utilities.noString(parentType)) 3576 t = parent; 3577 else { 3578 t = parent.predicate("fhir:"+name,index > -1); 3579 } 3580 composeBackboneElement(t, "collection", name, element, index); 3581 if (element.hasCollector()) { 3582 composeReference(t, "BiologicallyDerivedProductCollectionComponent", "collector", element.getCollector(), -1); 3583 } 3584 if (element.hasSource()) { 3585 composeReference(t, "BiologicallyDerivedProductCollectionComponent", "source", element.getSource(), -1); 3586 } 3587 if (element.hasCollected()) { 3588 composeType(t, "BiologicallyDerivedProductCollectionComponent", "collected", element.getCollected(), -1); 3589 } 3590 } 3591 3592 protected void composeBiologicallyDerivedProductPropertyComponent(Complex parent, String parentType, String name, BiologicallyDerivedProduct.BiologicallyDerivedProductPropertyComponent element, int index) { 3593 if (element == null) 3594 return; 3595 Complex t; 3596 if (Utilities.noString(parentType)) 3597 t = parent; 3598 else { 3599 t = parent.predicate("fhir:"+name,index > -1); 3600 } 3601 composeBackboneElement(t, "property", name, element, index); 3602 if (element.hasType()) { 3603 composeCodeableConcept(t, "BiologicallyDerivedProductPropertyComponent", "type", element.getType(), -1); 3604 } 3605 if (element.hasValue()) { 3606 composeType(t, "BiologicallyDerivedProductPropertyComponent", "value", element.getValue(), -1); 3607 } 3608 } 3609 3610 protected void composeBiologicallyDerivedProductDispense(Complex parent, String parentType, String name, BiologicallyDerivedProductDispense element, int index) { 3611 if (element == null) 3612 return; 3613 Complex t; 3614 if (Utilities.noString(parentType)) 3615 t = parent; 3616 else { 3617 t = parent.predicate("fhir:"+name,index > -1); 3618 } 3619 composeDomainResource(t, "BiologicallyDerivedProductDispense", name, element, index); 3620 for (int i = 0; i < element.getIdentifier().size(); i++) { 3621 composeIdentifier(t, "BiologicallyDerivedProductDispense", "identifier", element.getIdentifier().get(i), i); 3622 } 3623 for (int i = 0; i < element.getBasedOn().size(); i++) { 3624 composeReference(t, "BiologicallyDerivedProductDispense", "basedOn", element.getBasedOn().get(i), i); 3625 } 3626 for (int i = 0; i < element.getPartOf().size(); i++) { 3627 composeReference(t, "BiologicallyDerivedProductDispense", "partOf", element.getPartOf().get(i), i); 3628 } 3629 if (element.hasStatusElement()) { 3630 composeEnum(t, "BiologicallyDerivedProductDispense", "status", element.getStatusElement(), -1); 3631 } 3632 if (element.hasOriginRelationshipType()) { 3633 composeCodeableConcept(t, "BiologicallyDerivedProductDispense", "originRelationshipType", element.getOriginRelationshipType(), -1); 3634 } 3635 if (element.hasProduct()) { 3636 composeReference(t, "BiologicallyDerivedProductDispense", "product", element.getProduct(), -1); 3637 } 3638 if (element.hasPatient()) { 3639 composeReference(t, "BiologicallyDerivedProductDispense", "patient", element.getPatient(), -1); 3640 } 3641 if (element.hasMatchStatus()) { 3642 composeCodeableConcept(t, "BiologicallyDerivedProductDispense", "matchStatus", element.getMatchStatus(), -1); 3643 } 3644 for (int i = 0; i < element.getPerformer().size(); i++) { 3645 composeBiologicallyDerivedProductDispensePerformerComponent(t, "BiologicallyDerivedProductDispense", "performer", element.getPerformer().get(i), i); 3646 } 3647 if (element.hasLocation()) { 3648 composeReference(t, "BiologicallyDerivedProductDispense", "location", element.getLocation(), -1); 3649 } 3650 if (element.hasQuantity()) { 3651 composeQuantity(t, "BiologicallyDerivedProductDispense", "quantity", element.getQuantity(), -1); 3652 } 3653 if (element.hasPreparedDateElement()) { 3654 composeDateTime(t, "BiologicallyDerivedProductDispense", "preparedDate", element.getPreparedDateElement(), -1); 3655 } 3656 if (element.hasWhenHandedOverElement()) { 3657 composeDateTime(t, "BiologicallyDerivedProductDispense", "whenHandedOver", element.getWhenHandedOverElement(), -1); 3658 } 3659 if (element.hasDestination()) { 3660 composeReference(t, "BiologicallyDerivedProductDispense", "destination", element.getDestination(), -1); 3661 } 3662 for (int i = 0; i < element.getNote().size(); i++) { 3663 composeAnnotation(t, "BiologicallyDerivedProductDispense", "note", element.getNote().get(i), i); 3664 } 3665 if (element.hasUsageInstructionElement()) { 3666 composeString(t, "BiologicallyDerivedProductDispense", "usageInstruction", element.getUsageInstructionElement(), -1); 3667 } 3668 } 3669 3670 protected void composeBiologicallyDerivedProductDispensePerformerComponent(Complex parent, String parentType, String name, BiologicallyDerivedProductDispense.BiologicallyDerivedProductDispensePerformerComponent element, int index) { 3671 if (element == null) 3672 return; 3673 Complex t; 3674 if (Utilities.noString(parentType)) 3675 t = parent; 3676 else { 3677 t = parent.predicate("fhir:"+name,index > -1); 3678 } 3679 composeBackboneElement(t, "performer", name, element, index); 3680 if (element.hasFunction()) { 3681 composeCodeableConcept(t, "BiologicallyDerivedProductDispensePerformerComponent", "function", element.getFunction(), -1); 3682 } 3683 if (element.hasActor()) { 3684 composeReference(t, "BiologicallyDerivedProductDispensePerformerComponent", "actor", element.getActor(), -1); 3685 } 3686 } 3687 3688 protected void composeBodyStructure(Complex parent, String parentType, String name, BodyStructure element, int index) { 3689 if (element == null) 3690 return; 3691 Complex t; 3692 if (Utilities.noString(parentType)) 3693 t = parent; 3694 else { 3695 t = parent.predicate("fhir:"+name,index > -1); 3696 } 3697 composeDomainResource(t, "BodyStructure", name, element, index); 3698 for (int i = 0; i < element.getIdentifier().size(); i++) { 3699 composeIdentifier(t, "BodyStructure", "identifier", element.getIdentifier().get(i), i); 3700 } 3701 if (element.hasActiveElement()) { 3702 composeBoolean(t, "BodyStructure", "active", element.getActiveElement(), -1); 3703 } 3704 if (element.hasMorphology()) { 3705 composeCodeableConcept(t, "BodyStructure", "morphology", element.getMorphology(), -1); 3706 } 3707 for (int i = 0; i < element.getIncludedStructure().size(); i++) { 3708 composeBodyStructureIncludedStructureComponent(t, "BodyStructure", "includedStructure", element.getIncludedStructure().get(i), i); 3709 } 3710 for (int i = 0; i < element.getExcludedStructure().size(); i++) { 3711 composeBodyStructureIncludedStructureComponent(t, "BodyStructure", "excludedStructure", element.getExcludedStructure().get(i), i); 3712 } 3713 if (element.hasDescriptionElement()) { 3714 composeMarkdown(t, "BodyStructure", "description", element.getDescriptionElement(), -1); 3715 } 3716 for (int i = 0; i < element.getImage().size(); i++) { 3717 composeAttachment(t, "BodyStructure", "image", element.getImage().get(i), i); 3718 } 3719 if (element.hasPatient()) { 3720 composeReference(t, "BodyStructure", "patient", element.getPatient(), -1); 3721 } 3722 } 3723 3724 protected void composeBodyStructureIncludedStructureComponent(Complex parent, String parentType, String name, BodyStructure.BodyStructureIncludedStructureComponent element, int index) { 3725 if (element == null) 3726 return; 3727 Complex t; 3728 if (Utilities.noString(parentType)) 3729 t = parent; 3730 else { 3731 t = parent.predicate("fhir:"+name,index > -1); 3732 } 3733 composeBackboneElement(t, "includedStructure", name, element, index); 3734 if (element.hasStructure()) { 3735 composeCodeableConcept(t, "BodyStructureIncludedStructureComponent", "structure", element.getStructure(), -1); 3736 } 3737 if (element.hasLaterality()) { 3738 composeCodeableConcept(t, "BodyStructureIncludedStructureComponent", "laterality", element.getLaterality(), -1); 3739 } 3740 for (int i = 0; i < element.getBodyLandmarkOrientation().size(); i++) { 3741 composeBodyStructureIncludedStructureBodyLandmarkOrientationComponent(t, "BodyStructureIncludedStructureComponent", "bodyLandmarkOrientation", element.getBodyLandmarkOrientation().get(i), i); 3742 } 3743 for (int i = 0; i < element.getSpatialReference().size(); i++) { 3744 composeReference(t, "BodyStructureIncludedStructureComponent", "spatialReference", element.getSpatialReference().get(i), i); 3745 } 3746 for (int i = 0; i < element.getQualifier().size(); i++) { 3747 composeCodeableConcept(t, "BodyStructureIncludedStructureComponent", "qualifier", element.getQualifier().get(i), i); 3748 } 3749 } 3750 3751 protected void composeBodyStructureIncludedStructureBodyLandmarkOrientationComponent(Complex parent, String parentType, String name, BodyStructure.BodyStructureIncludedStructureBodyLandmarkOrientationComponent element, int index) { 3752 if (element == null) 3753 return; 3754 Complex t; 3755 if (Utilities.noString(parentType)) 3756 t = parent; 3757 else { 3758 t = parent.predicate("fhir:"+name,index > -1); 3759 } 3760 composeBackboneElement(t, "bodyLandmarkOrientation", name, element, index); 3761 for (int i = 0; i < element.getLandmarkDescription().size(); i++) { 3762 composeCodeableConcept(t, "BodyStructureIncludedStructureBodyLandmarkOrientationComponent", "landmarkDescription", element.getLandmarkDescription().get(i), i); 3763 } 3764 for (int i = 0; i < element.getClockFacePosition().size(); i++) { 3765 composeCodeableConcept(t, "BodyStructureIncludedStructureBodyLandmarkOrientationComponent", "clockFacePosition", element.getClockFacePosition().get(i), i); 3766 } 3767 for (int i = 0; i < element.getDistanceFromLandmark().size(); i++) { 3768 composeBodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent(t, "BodyStructureIncludedStructureBodyLandmarkOrientationComponent", "distanceFromLandmark", element.getDistanceFromLandmark().get(i), i); 3769 } 3770 for (int i = 0; i < element.getSurfaceOrientation().size(); i++) { 3771 composeCodeableConcept(t, "BodyStructureIncludedStructureBodyLandmarkOrientationComponent", "surfaceOrientation", element.getSurfaceOrientation().get(i), i); 3772 } 3773 } 3774 3775 protected void composeBodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent(Complex parent, String parentType, String name, BodyStructure.BodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent element, int index) { 3776 if (element == null) 3777 return; 3778 Complex t; 3779 if (Utilities.noString(parentType)) 3780 t = parent; 3781 else { 3782 t = parent.predicate("fhir:"+name,index > -1); 3783 } 3784 composeBackboneElement(t, "distanceFromLandmark", name, element, index); 3785 for (int i = 0; i < element.getDevice().size(); i++) { 3786 composeCodeableReference(t, "BodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent", "device", element.getDevice().get(i), i); 3787 } 3788 for (int i = 0; i < element.getValue().size(); i++) { 3789 composeQuantity(t, "BodyStructureIncludedStructureBodyLandmarkOrientationDistanceFromLandmarkComponent", "value", element.getValue().get(i), i); 3790 } 3791 } 3792 3793 protected void composeBundle(Complex parent, String parentType, String name, Bundle element, int index) { 3794 if (element == null) 3795 return; 3796 Complex t; 3797 if (Utilities.noString(parentType)) 3798 t = parent; 3799 else { 3800 t = parent.predicate("fhir:"+name,index > -1); 3801 } 3802 composeResource(t, "Bundle", name, element, index); 3803 if (element.hasIdentifier()) { 3804 composeIdentifier(t, "Bundle", "identifier", element.getIdentifier(), -1); 3805 } 3806 if (element.hasTypeElement()) { 3807 composeEnum(t, "Bundle", "type", element.getTypeElement(), -1); 3808 } 3809 if (element.hasTimestampElement()) { 3810 composeInstant(t, "Bundle", "timestamp", element.getTimestampElement(), -1); 3811 } 3812 if (element.hasTotalElement()) { 3813 composeUnsignedInt(t, "Bundle", "total", element.getTotalElement(), -1); 3814 } 3815 for (int i = 0; i < element.getLink().size(); i++) { 3816 composeBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i); 3817 } 3818 for (int i = 0; i < element.getEntry().size(); i++) { 3819 composeBundleEntryComponent(t, "Bundle", "entry", element.getEntry().get(i), i); 3820 } 3821 if (element.hasSignature()) { 3822 composeSignature(t, "Bundle", "signature", element.getSignature(), -1); 3823 } 3824 if (element.hasIssues()) { 3825 composeResource(t, "Bundle", "issues", element.getIssues(), -1); 3826 } 3827 } 3828 3829 protected void composeBundleLinkComponent(Complex parent, String parentType, String name, Bundle.BundleLinkComponent element, int index) { 3830 if (element == null) 3831 return; 3832 Complex t; 3833 if (Utilities.noString(parentType)) 3834 t = parent; 3835 else { 3836 t = parent.predicate("fhir:"+name,index > -1); 3837 } 3838 composeBackboneElement(t, "link", name, element, index); 3839 if (element.hasRelationElement()) { 3840 composeEnum(t, "BundleLinkComponent", "relation", element.getRelationElement(), -1); 3841 } 3842 if (element.hasUrlElement()) { 3843 composeUri(t, "BundleLinkComponent", "url", element.getUrlElement(), -1); 3844 } 3845 } 3846 3847 protected void composeBundleEntryComponent(Complex parent, String parentType, String name, Bundle.BundleEntryComponent element, int index) { 3848 if (element == null) 3849 return; 3850 Complex t; 3851 if (Utilities.noString(parentType)) 3852 t = parent; 3853 else { 3854 t = parent.predicate("fhir:"+name,index > -1); 3855 } 3856 composeBackboneElement(t, "entry", name, element, index); 3857 for (int i = 0; i < element.getLink().size(); i++) { 3858 composeBundleLinkComponent(t, "BundleEntryComponent", "link", element.getLink().get(i), i); 3859 } 3860 if (element.hasFullUrlElement()) { 3861 composeUri(t, "BundleEntryComponent", "fullUrl", element.getFullUrlElement(), -1); 3862 } 3863 if (element.hasResource()) { 3864 composeResource(t, "BundleEntryComponent", "resource", element.getResource(), -1); 3865 } 3866 if (element.hasSearch()) { 3867 composeBundleEntrySearchComponent(t, "BundleEntryComponent", "search", element.getSearch(), -1); 3868 } 3869 if (element.hasRequest()) { 3870 composeBundleEntryRequestComponent(t, "BundleEntryComponent", "request", element.getRequest(), -1); 3871 } 3872 if (element.hasResponse()) { 3873 composeBundleEntryResponseComponent(t, "BundleEntryComponent", "response", element.getResponse(), -1); 3874 } 3875 } 3876 3877 protected void composeBundleEntrySearchComponent(Complex parent, String parentType, String name, Bundle.BundleEntrySearchComponent element, int index) { 3878 if (element == null) 3879 return; 3880 Complex t; 3881 if (Utilities.noString(parentType)) 3882 t = parent; 3883 else { 3884 t = parent.predicate("fhir:"+name,index > -1); 3885 } 3886 composeBackboneElement(t, "search", name, element, index); 3887 if (element.hasModeElement()) { 3888 composeEnum(t, "BundleEntrySearchComponent", "mode", element.getModeElement(), -1); 3889 } 3890 if (element.hasScoreElement()) { 3891 composeDecimal(t, "BundleEntrySearchComponent", "score", element.getScoreElement(), -1); 3892 } 3893 } 3894 3895 protected void composeBundleEntryRequestComponent(Complex parent, String parentType, String name, Bundle.BundleEntryRequestComponent element, int index) { 3896 if (element == null) 3897 return; 3898 Complex t; 3899 if (Utilities.noString(parentType)) 3900 t = parent; 3901 else { 3902 t = parent.predicate("fhir:"+name,index > -1); 3903 } 3904 composeBackboneElement(t, "request", name, element, index); 3905 if (element.hasMethodElement()) { 3906 composeEnum(t, "BundleEntryRequestComponent", "method", element.getMethodElement(), -1); 3907 } 3908 if (element.hasUrlElement()) { 3909 composeUri(t, "BundleEntryRequestComponent", "url", element.getUrlElement(), -1); 3910 } 3911 if (element.hasIfNoneMatchElement()) { 3912 composeString(t, "BundleEntryRequestComponent", "ifNoneMatch", element.getIfNoneMatchElement(), -1); 3913 } 3914 if (element.hasIfModifiedSinceElement()) { 3915 composeInstant(t, "BundleEntryRequestComponent", "ifModifiedSince", element.getIfModifiedSinceElement(), -1); 3916 } 3917 if (element.hasIfMatchElement()) { 3918 composeString(t, "BundleEntryRequestComponent", "ifMatch", element.getIfMatchElement(), -1); 3919 } 3920 if (element.hasIfNoneExistElement()) { 3921 composeString(t, "BundleEntryRequestComponent", "ifNoneExist", element.getIfNoneExistElement(), -1); 3922 } 3923 } 3924 3925 protected void composeBundleEntryResponseComponent(Complex parent, String parentType, String name, Bundle.BundleEntryResponseComponent element, int index) { 3926 if (element == null) 3927 return; 3928 Complex t; 3929 if (Utilities.noString(parentType)) 3930 t = parent; 3931 else { 3932 t = parent.predicate("fhir:"+name,index > -1); 3933 } 3934 composeBackboneElement(t, "response", name, element, index); 3935 if (element.hasStatusElement()) { 3936 composeString(t, "BundleEntryResponseComponent", "status", element.getStatusElement(), -1); 3937 } 3938 if (element.hasLocationElement()) { 3939 composeUri(t, "BundleEntryResponseComponent", "location", element.getLocationElement(), -1); 3940 } 3941 if (element.hasEtagElement()) { 3942 composeString(t, "BundleEntryResponseComponent", "etag", element.getEtagElement(), -1); 3943 } 3944 if (element.hasLastModifiedElement()) { 3945 composeInstant(t, "BundleEntryResponseComponent", "lastModified", element.getLastModifiedElement(), -1); 3946 } 3947 if (element.hasOutcome()) { 3948 composeResource(t, "BundleEntryResponseComponent", "outcome", element.getOutcome(), -1); 3949 } 3950 } 3951 3952 protected void composeCapabilityStatement(Complex parent, String parentType, String name, CapabilityStatement element, int index) { 3953 if (element == null) 3954 return; 3955 Complex t; 3956 if (Utilities.noString(parentType)) 3957 t = parent; 3958 else { 3959 t = parent.predicate("fhir:"+name,index > -1); 3960 } 3961 composeCanonicalResource(t, "CapabilityStatement", name, element, index); 3962 if (element.hasUrlElement()) { 3963 composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1); 3964 } 3965 for (int i = 0; i < element.getIdentifier().size(); i++) { 3966 composeIdentifier(t, "CapabilityStatement", "identifier", element.getIdentifier().get(i), i); 3967 } 3968 if (element.hasVersionElement()) { 3969 composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1); 3970 } 3971 if (element.hasVersionAlgorithm()) { 3972 composeType(t, "CapabilityStatement", "versionAlgorithm", element.getVersionAlgorithm(), -1); 3973 } 3974 if (element.hasNameElement()) { 3975 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 3976 } 3977 if (element.hasTitleElement()) { 3978 composeString(t, "CapabilityStatement", "title", element.getTitleElement(), -1); 3979 } 3980 if (element.hasStatusElement()) { 3981 composeEnum(t, "CapabilityStatement", "status", element.getStatusElement(), -1); 3982 } 3983 if (element.hasExperimentalElement()) { 3984 composeBoolean(t, "CapabilityStatement", "experimental", element.getExperimentalElement(), -1); 3985 } 3986 if (element.hasDateElement()) { 3987 composeDateTime(t, "CapabilityStatement", "date", element.getDateElement(), -1); 3988 } 3989 if (element.hasPublisherElement()) { 3990 composeString(t, "CapabilityStatement", "publisher", element.getPublisherElement(), -1); 3991 } 3992 for (int i = 0; i < element.getContact().size(); i++) { 3993 composeContactDetail(t, "CapabilityStatement", "contact", element.getContact().get(i), i); 3994 } 3995 if (element.hasDescriptionElement()) { 3996 composeMarkdown(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1); 3997 } 3998 for (int i = 0; i < element.getUseContext().size(); i++) { 3999 composeUsageContext(t, "CapabilityStatement", "useContext", element.getUseContext().get(i), i); 4000 } 4001 for (int i = 0; i < element.getJurisdiction().size(); i++) { 4002 composeCodeableConcept(t, "CapabilityStatement", "jurisdiction", element.getJurisdiction().get(i), i); 4003 } 4004 if (element.hasPurposeElement()) { 4005 composeMarkdown(t, "CapabilityStatement", "purpose", element.getPurposeElement(), -1); 4006 } 4007 if (element.hasCopyrightElement()) { 4008 composeMarkdown(t, "CapabilityStatement", "copyright", element.getCopyrightElement(), -1); 4009 } 4010 if (element.hasCopyrightLabelElement()) { 4011 composeString(t, "CapabilityStatement", "copyrightLabel", element.getCopyrightLabelElement(), -1); 4012 } 4013 if (element.hasKindElement()) { 4014 composeEnum(t, "CapabilityStatement", "kind", element.getKindElement(), -1); 4015 } 4016 for (int i = 0; i < element.getInstantiates().size(); i++) { 4017 composeCanonical(t, "CapabilityStatement", "instantiates", element.getInstantiates().get(i), i); 4018 } 4019 for (int i = 0; i < element.getImports().size(); i++) { 4020 composeCanonical(t, "CapabilityStatement", "imports", element.getImports().get(i), i); 4021 } 4022 if (element.hasSoftware()) { 4023 composeCapabilityStatementSoftwareComponent(t, "CapabilityStatement", "software", element.getSoftware(), -1); 4024 } 4025 if (element.hasImplementation()) { 4026 composeCapabilityStatementImplementationComponent(t, "CapabilityStatement", "implementation", element.getImplementation(), -1); 4027 } 4028 if (element.hasFhirVersionElement()) { 4029 composeEnum(t, "CapabilityStatement", "fhirVersion", element.getFhirVersionElement(), -1); 4030 } 4031 for (int i = 0; i < element.getFormat().size(); i++) { 4032 composeCode(t, "CapabilityStatement", "format", element.getFormat().get(i), i); 4033 } 4034 for (int i = 0; i < element.getPatchFormat().size(); i++) { 4035 composeCode(t, "CapabilityStatement", "patchFormat", element.getPatchFormat().get(i), i); 4036 } 4037 for (int i = 0; i < element.getAcceptLanguage().size(); i++) { 4038 composeCode(t, "CapabilityStatement", "acceptLanguage", element.getAcceptLanguage().get(i), i); 4039 } 4040 for (int i = 0; i < element.getImplementationGuide().size(); i++) { 4041 composeCanonical(t, "CapabilityStatement", "implementationGuide", element.getImplementationGuide().get(i), i); 4042 } 4043 for (int i = 0; i < element.getRest().size(); i++) { 4044 composeCapabilityStatementRestComponent(t, "CapabilityStatement", "rest", element.getRest().get(i), i); 4045 } 4046 for (int i = 0; i < element.getMessaging().size(); i++) { 4047 composeCapabilityStatementMessagingComponent(t, "CapabilityStatement", "messaging", element.getMessaging().get(i), i); 4048 } 4049 for (int i = 0; i < element.getDocument().size(); i++) { 4050 composeCapabilityStatementDocumentComponent(t, "CapabilityStatement", "document", element.getDocument().get(i), i); 4051 } 4052 } 4053 4054 protected void composeCapabilityStatementSoftwareComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementSoftwareComponent element, int index) { 4055 if (element == null) 4056 return; 4057 Complex t; 4058 if (Utilities.noString(parentType)) 4059 t = parent; 4060 else { 4061 t = parent.predicate("fhir:"+name,index > -1); 4062 } 4063 composeBackboneElement(t, "software", name, element, index); 4064 if (element.hasNameElement()) { 4065 composeString(t, "CapabilityStatementSoftwareComponent", "name", element.getNameElement(), -1); 4066 } 4067 if (element.hasVersionElement()) { 4068 composeString(t, "CapabilityStatementSoftwareComponent", "version", element.getVersionElement(), -1); 4069 } 4070 if (element.hasReleaseDateElement()) { 4071 composeDateTime(t, "CapabilityStatementSoftwareComponent", "releaseDate", element.getReleaseDateElement(), -1); 4072 } 4073 } 4074 4075 protected void composeCapabilityStatementImplementationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementImplementationComponent element, int index) { 4076 if (element == null) 4077 return; 4078 Complex t; 4079 if (Utilities.noString(parentType)) 4080 t = parent; 4081 else { 4082 t = parent.predicate("fhir:"+name,index > -1); 4083 } 4084 composeBackboneElement(t, "implementation", name, element, index); 4085 if (element.hasDescriptionElement()) { 4086 composeMarkdown(t, "CapabilityStatementImplementationComponent", "description", element.getDescriptionElement(), -1); 4087 } 4088 if (element.hasUrlElement()) { 4089 composeUrl(t, "CapabilityStatementImplementationComponent", "url", element.getUrlElement(), -1); 4090 } 4091 if (element.hasCustodian()) { 4092 composeReference(t, "CapabilityStatementImplementationComponent", "custodian", element.getCustodian(), -1); 4093 } 4094 } 4095 4096 protected void composeCapabilityStatementRestComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestComponent element, int index) { 4097 if (element == null) 4098 return; 4099 Complex t; 4100 if (Utilities.noString(parentType)) 4101 t = parent; 4102 else { 4103 t = parent.predicate("fhir:"+name,index > -1); 4104 } 4105 composeBackboneElement(t, "rest", name, element, index); 4106 if (element.hasModeElement()) { 4107 composeEnum(t, "CapabilityStatementRestComponent", "mode", element.getModeElement(), -1); 4108 } 4109 if (element.hasDocumentationElement()) { 4110 composeMarkdown(t, "CapabilityStatementRestComponent", "documentation", element.getDocumentationElement(), -1); 4111 } 4112 if (element.hasSecurity()) { 4113 composeCapabilityStatementRestSecurityComponent(t, "CapabilityStatementRestComponent", "security", element.getSecurity(), -1); 4114 } 4115 for (int i = 0; i < element.getResource().size(); i++) { 4116 composeCapabilityStatementRestResourceComponent(t, "CapabilityStatementRestComponent", "resource", element.getResource().get(i), i); 4117 } 4118 for (int i = 0; i < element.getInteraction().size(); i++) { 4119 composeCapabilityStatementSystemInteractionComponent(t, "CapabilityStatementRestComponent", "interaction", element.getInteraction().get(i), i); 4120 } 4121 for (int i = 0; i < element.getSearchParam().size(); i++) { 4122 composeCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatementRestComponent", "searchParam", element.getSearchParam().get(i), i); 4123 } 4124 for (int i = 0; i < element.getOperation().size(); i++) { 4125 composeCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatementRestComponent", "operation", element.getOperation().get(i), i); 4126 } 4127 for (int i = 0; i < element.getCompartment().size(); i++) { 4128 composeCanonical(t, "CapabilityStatementRestComponent", "compartment", element.getCompartment().get(i), i); 4129 } 4130 } 4131 4132 protected void composeCapabilityStatementRestSecurityComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityComponent element, int index) { 4133 if (element == null) 4134 return; 4135 Complex t; 4136 if (Utilities.noString(parentType)) 4137 t = parent; 4138 else { 4139 t = parent.predicate("fhir:"+name,index > -1); 4140 } 4141 composeBackboneElement(t, "security", name, element, index); 4142 if (element.hasCorsElement()) { 4143 composeBoolean(t, "CapabilityStatementRestSecurityComponent", "cors", element.getCorsElement(), -1); 4144 } 4145 for (int i = 0; i < element.getService().size(); i++) { 4146 composeCodeableConcept(t, "CapabilityStatementRestSecurityComponent", "service", element.getService().get(i), i); 4147 } 4148 if (element.hasDescriptionElement()) { 4149 composeMarkdown(t, "CapabilityStatementRestSecurityComponent", "description", element.getDescriptionElement(), -1); 4150 } 4151 } 4152 4153 protected void composeCapabilityStatementRestResourceComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceComponent element, int index) { 4154 if (element == null) 4155 return; 4156 Complex t; 4157 if (Utilities.noString(parentType)) 4158 t = parent; 4159 else { 4160 t = parent.predicate("fhir:"+name,index > -1); 4161 } 4162 composeBackboneElement(t, "resource", name, element, index); 4163 if (element.hasTypeElement()) { 4164 composeCode(t, "CapabilityStatementRestResourceComponent", "type", element.getTypeElement(), -1); 4165 } 4166 if (element.hasProfileElement()) { 4167 composeCanonical(t, "CapabilityStatementRestResourceComponent", "profile", element.getProfileElement(), -1); 4168 } 4169 for (int i = 0; i < element.getSupportedProfile().size(); i++) { 4170 composeCanonical(t, "CapabilityStatementRestResourceComponent", "supportedProfile", element.getSupportedProfile().get(i), i); 4171 } 4172 if (element.hasDocumentationElement()) { 4173 composeMarkdown(t, "CapabilityStatementRestResourceComponent", "documentation", element.getDocumentationElement(), -1); 4174 } 4175 for (int i = 0; i < element.getInteraction().size(); i++) { 4176 composeCapabilityStatementResourceInteractionComponent(t, "CapabilityStatementRestResourceComponent", "interaction", element.getInteraction().get(i), i); 4177 } 4178 if (element.hasVersioningElement()) { 4179 composeEnum(t, "CapabilityStatementRestResourceComponent", "versioning", element.getVersioningElement(), -1); 4180 } 4181 if (element.hasReadHistoryElement()) { 4182 composeBoolean(t, "CapabilityStatementRestResourceComponent", "readHistory", element.getReadHistoryElement(), -1); 4183 } 4184 if (element.hasUpdateCreateElement()) { 4185 composeBoolean(t, "CapabilityStatementRestResourceComponent", "updateCreate", element.getUpdateCreateElement(), -1); 4186 } 4187 if (element.hasConditionalCreateElement()) { 4188 composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalCreate", element.getConditionalCreateElement(), -1); 4189 } 4190 if (element.hasConditionalReadElement()) { 4191 composeEnum(t, "CapabilityStatementRestResourceComponent", "conditionalRead", element.getConditionalReadElement(), -1); 4192 } 4193 if (element.hasConditionalUpdateElement()) { 4194 composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalUpdate", element.getConditionalUpdateElement(), -1); 4195 } 4196 if (element.hasConditionalPatchElement()) { 4197 composeBoolean(t, "CapabilityStatementRestResourceComponent", "conditionalPatch", element.getConditionalPatchElement(), -1); 4198 } 4199 if (element.hasConditionalDeleteElement()) { 4200 composeEnum(t, "CapabilityStatementRestResourceComponent", "conditionalDelete", element.getConditionalDeleteElement(), -1); 4201 } 4202 for (int i = 0; i < element.getReferencePolicy().size(); i++) { 4203 composeEnum(t, "CapabilityStatementRestResourceComponent", "referencePolicy", element.getReferencePolicy().get(i), i); 4204 } 4205 for (int i = 0; i < element.getSearchInclude().size(); i++) { 4206 composeString(t, "CapabilityStatementRestResourceComponent", "searchInclude", element.getSearchInclude().get(i), i); 4207 } 4208 for (int i = 0; i < element.getSearchRevInclude().size(); i++) { 4209 composeString(t, "CapabilityStatementRestResourceComponent", "searchRevInclude", element.getSearchRevInclude().get(i), i); 4210 } 4211 for (int i = 0; i < element.getSearchParam().size(); i++) { 4212 composeCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatementRestResourceComponent", "searchParam", element.getSearchParam().get(i), i); 4213 } 4214 for (int i = 0; i < element.getOperation().size(); i++) { 4215 composeCapabilityStatementRestResourceOperationComponent(t, "CapabilityStatementRestResourceComponent", "operation", element.getOperation().get(i), i); 4216 } 4217 } 4218 4219 protected void composeCapabilityStatementResourceInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.ResourceInteractionComponent element, int index) { 4220 if (element == null) 4221 return; 4222 Complex t; 4223 if (Utilities.noString(parentType)) 4224 t = parent; 4225 else { 4226 t = parent.predicate("fhir:"+name,index > -1); 4227 } 4228 composeBackboneElement(t, "interaction", name, element, index); 4229 if (element.hasCodeElement()) { 4230 composeEnum(t, "ResourceInteractionComponent", "code", element.getCodeElement(), -1); 4231 } 4232 if (element.hasDocumentationElement()) { 4233 composeMarkdown(t, "ResourceInteractionComponent", "documentation", element.getDocumentationElement(), -1); 4234 } 4235 } 4236 4237 protected void composeCapabilityStatementRestResourceSearchParamComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent element, int index) { 4238 if (element == null) 4239 return; 4240 Complex t; 4241 if (Utilities.noString(parentType)) 4242 t = parent; 4243 else { 4244 t = parent.predicate("fhir:"+name,index > -1); 4245 } 4246 composeBackboneElement(t, "searchParam", name, element, index); 4247 if (element.hasNameElement()) { 4248 composeString(t, "CapabilityStatementRestResourceSearchParamComponent", "name", element.getNameElement(), -1); 4249 } 4250 if (element.hasDefinitionElement()) { 4251 composeCanonical(t, "CapabilityStatementRestResourceSearchParamComponent", "definition", element.getDefinitionElement(), -1); 4252 } 4253 if (element.hasTypeElement()) { 4254 composeEnum(t, "CapabilityStatementRestResourceSearchParamComponent", "type", element.getTypeElement(), -1); 4255 } 4256 if (element.hasDocumentationElement()) { 4257 composeMarkdown(t, "CapabilityStatementRestResourceSearchParamComponent", "documentation", element.getDocumentationElement(), -1); 4258 } 4259 } 4260 4261 protected void composeCapabilityStatementRestResourceOperationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceOperationComponent element, int index) { 4262 if (element == null) 4263 return; 4264 Complex t; 4265 if (Utilities.noString(parentType)) 4266 t = parent; 4267 else { 4268 t = parent.predicate("fhir:"+name,index > -1); 4269 } 4270 composeBackboneElement(t, "operation", name, element, index); 4271 if (element.hasNameElement()) { 4272 composeString(t, "CapabilityStatementRestResourceOperationComponent", "name", element.getNameElement(), -1); 4273 } 4274 if (element.hasDefinitionElement()) { 4275 composeCanonical(t, "CapabilityStatementRestResourceOperationComponent", "definition", element.getDefinitionElement(), -1); 4276 } 4277 if (element.hasDocumentationElement()) { 4278 composeMarkdown(t, "CapabilityStatementRestResourceOperationComponent", "documentation", element.getDocumentationElement(), -1); 4279 } 4280 } 4281 4282 protected void composeCapabilityStatementSystemInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.SystemInteractionComponent element, int index) { 4283 if (element == null) 4284 return; 4285 Complex t; 4286 if (Utilities.noString(parentType)) 4287 t = parent; 4288 else { 4289 t = parent.predicate("fhir:"+name,index > -1); 4290 } 4291 composeBackboneElement(t, "interaction", name, element, index); 4292 if (element.hasCodeElement()) { 4293 composeEnum(t, "SystemInteractionComponent", "code", element.getCodeElement(), -1); 4294 } 4295 if (element.hasDocumentationElement()) { 4296 composeMarkdown(t, "SystemInteractionComponent", "documentation", element.getDocumentationElement(), -1); 4297 } 4298 } 4299 4300 protected void composeCapabilityStatementMessagingComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingComponent element, int index) { 4301 if (element == null) 4302 return; 4303 Complex t; 4304 if (Utilities.noString(parentType)) 4305 t = parent; 4306 else { 4307 t = parent.predicate("fhir:"+name,index > -1); 4308 } 4309 composeBackboneElement(t, "messaging", name, element, index); 4310 for (int i = 0; i < element.getEndpoint().size(); i++) { 4311 composeCapabilityStatementMessagingEndpointComponent(t, "CapabilityStatementMessagingComponent", "endpoint", element.getEndpoint().get(i), i); 4312 } 4313 if (element.hasReliableCacheElement()) { 4314 composeUnsignedInt(t, "CapabilityStatementMessagingComponent", "reliableCache", element.getReliableCacheElement(), -1); 4315 } 4316 if (element.hasDocumentationElement()) { 4317 composeMarkdown(t, "CapabilityStatementMessagingComponent", "documentation", element.getDocumentationElement(), -1); 4318 } 4319 for (int i = 0; i < element.getSupportedMessage().size(); i++) { 4320 composeCapabilityStatementMessagingSupportedMessageComponent(t, "CapabilityStatementMessagingComponent", "supportedMessage", element.getSupportedMessage().get(i), i); 4321 } 4322 } 4323 4324 protected void composeCapabilityStatementMessagingEndpointComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEndpointComponent element, int index) { 4325 if (element == null) 4326 return; 4327 Complex t; 4328 if (Utilities.noString(parentType)) 4329 t = parent; 4330 else { 4331 t = parent.predicate("fhir:"+name,index > -1); 4332 } 4333 composeBackboneElement(t, "endpoint", name, element, index); 4334 if (element.hasProtocol()) { 4335 composeCoding(t, "CapabilityStatementMessagingEndpointComponent", "protocol", element.getProtocol(), -1); 4336 } 4337 if (element.hasAddressElement()) { 4338 composeUrl(t, "CapabilityStatementMessagingEndpointComponent", "address", element.getAddressElement(), -1); 4339 } 4340 } 4341 4342 protected void composeCapabilityStatementMessagingSupportedMessageComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent element, int index) { 4343 if (element == null) 4344 return; 4345 Complex t; 4346 if (Utilities.noString(parentType)) 4347 t = parent; 4348 else { 4349 t = parent.predicate("fhir:"+name,index > -1); 4350 } 4351 composeBackboneElement(t, "supportedMessage", name, element, index); 4352 if (element.hasModeElement()) { 4353 composeEnum(t, "CapabilityStatementMessagingSupportedMessageComponent", "mode", element.getModeElement(), -1); 4354 } 4355 if (element.hasDefinitionElement()) { 4356 composeCanonical(t, "CapabilityStatementMessagingSupportedMessageComponent", "definition", element.getDefinitionElement(), -1); 4357 } 4358 } 4359 4360 protected void composeCapabilityStatementDocumentComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementDocumentComponent element, int index) { 4361 if (element == null) 4362 return; 4363 Complex t; 4364 if (Utilities.noString(parentType)) 4365 t = parent; 4366 else { 4367 t = parent.predicate("fhir:"+name,index > -1); 4368 } 4369 composeBackboneElement(t, "document", name, element, index); 4370 if (element.hasModeElement()) { 4371 composeEnum(t, "CapabilityStatementDocumentComponent", "mode", element.getModeElement(), -1); 4372 } 4373 if (element.hasDocumentationElement()) { 4374 composeMarkdown(t, "CapabilityStatementDocumentComponent", "documentation", element.getDocumentationElement(), -1); 4375 } 4376 if (element.hasProfileElement()) { 4377 composeCanonical(t, "CapabilityStatementDocumentComponent", "profile", element.getProfileElement(), -1); 4378 } 4379 } 4380 4381 protected void composeCarePlan(Complex parent, String parentType, String name, CarePlan element, int index) { 4382 if (element == null) 4383 return; 4384 Complex t; 4385 if (Utilities.noString(parentType)) 4386 t = parent; 4387 else { 4388 t = parent.predicate("fhir:"+name,index > -1); 4389 } 4390 composeDomainResource(t, "CarePlan", name, element, index); 4391 for (int i = 0; i < element.getIdentifier().size(); i++) { 4392 composeIdentifier(t, "CarePlan", "identifier", element.getIdentifier().get(i), i); 4393 } 4394 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) { 4395 composeCanonical(t, "CarePlan", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 4396 } 4397 for (int i = 0; i < element.getInstantiatesUri().size(); i++) { 4398 composeUri(t, "CarePlan", "instantiatesUri", element.getInstantiatesUri().get(i), i); 4399 } 4400 for (int i = 0; i < element.getBasedOn().size(); i++) { 4401 composeReference(t, "CarePlan", "basedOn", element.getBasedOn().get(i), i); 4402 } 4403 for (int i = 0; i < element.getReplaces().size(); i++) { 4404 composeReference(t, "CarePlan", "replaces", element.getReplaces().get(i), i); 4405 } 4406 for (int i = 0; i < element.getPartOf().size(); i++) { 4407 composeReference(t, "CarePlan", "partOf", element.getPartOf().get(i), i); 4408 } 4409 if (element.hasStatusElement()) { 4410 composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1); 4411 } 4412 if (element.hasIntentElement()) { 4413 composeEnum(t, "CarePlan", "intent", element.getIntentElement(), -1); 4414 } 4415 for (int i = 0; i < element.getCategory().size(); i++) { 4416 composeCodeableConcept(t, "CarePlan", "category", element.getCategory().get(i), i); 4417 } 4418 if (element.hasTitleElement()) { 4419 composeString(t, "CarePlan", "title", element.getTitleElement(), -1); 4420 } 4421 if (element.hasDescriptionElement()) { 4422 composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1); 4423 } 4424 if (element.hasSubject()) { 4425 composeReference(t, "CarePlan", "subject", element.getSubject(), -1); 4426 } 4427 if (element.hasEncounter()) { 4428 composeReference(t, "CarePlan", "encounter", element.getEncounter(), -1); 4429 } 4430 if (element.hasPeriod()) { 4431 composePeriod(t, "CarePlan", "period", element.getPeriod(), -1); 4432 } 4433 if (element.hasCreatedElement()) { 4434 composeDateTime(t, "CarePlan", "created", element.getCreatedElement(), -1); 4435 } 4436 if (element.hasCustodian()) { 4437 composeReference(t, "CarePlan", "custodian", element.getCustodian(), -1); 4438 } 4439 for (int i = 0; i < element.getContributor().size(); i++) { 4440 composeReference(t, "CarePlan", "contributor", element.getContributor().get(i), i); 4441 } 4442 for (int i = 0; i < element.getCareTeam().size(); i++) { 4443 composeReference(t, "CarePlan", "careTeam", element.getCareTeam().get(i), i); 4444 } 4445 for (int i = 0; i < element.getAddresses().size(); i++) { 4446 composeCodeableReference(t, "CarePlan", "addresses", element.getAddresses().get(i), i); 4447 } 4448 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 4449 composeReference(t, "CarePlan", "supportingInfo", element.getSupportingInfo().get(i), i); 4450 } 4451 for (int i = 0; i < element.getGoal().size(); i++) { 4452 composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i); 4453 } 4454 for (int i = 0; i < element.getActivity().size(); i++) { 4455 composeCarePlanActivityComponent(t, "CarePlan", "activity", element.getActivity().get(i), i); 4456 } 4457 for (int i = 0; i < element.getNote().size(); i++) { 4458 composeAnnotation(t, "CarePlan", "note", element.getNote().get(i), i); 4459 } 4460 } 4461 4462 protected void composeCarePlanActivityComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityComponent element, int index) { 4463 if (element == null) 4464 return; 4465 Complex t; 4466 if (Utilities.noString(parentType)) 4467 t = parent; 4468 else { 4469 t = parent.predicate("fhir:"+name,index > -1); 4470 } 4471 composeBackboneElement(t, "activity", name, element, index); 4472 for (int i = 0; i < element.getPerformedActivity().size(); i++) { 4473 composeCodeableReference(t, "CarePlanActivityComponent", "performedActivity", element.getPerformedActivity().get(i), i); 4474 } 4475 for (int i = 0; i < element.getProgress().size(); i++) { 4476 composeAnnotation(t, "CarePlanActivityComponent", "progress", element.getProgress().get(i), i); 4477 } 4478 if (element.hasPlannedActivityReference()) { 4479 composeReference(t, "CarePlanActivityComponent", "plannedActivityReference", element.getPlannedActivityReference(), -1); 4480 } 4481 } 4482 4483 protected void composeCareTeam(Complex parent, String parentType, String name, CareTeam element, int index) { 4484 if (element == null) 4485 return; 4486 Complex t; 4487 if (Utilities.noString(parentType)) 4488 t = parent; 4489 else { 4490 t = parent.predicate("fhir:"+name,index > -1); 4491 } 4492 composeDomainResource(t, "CareTeam", name, element, index); 4493 for (int i = 0; i < element.getIdentifier().size(); i++) { 4494 composeIdentifier(t, "CareTeam", "identifier", element.getIdentifier().get(i), i); 4495 } 4496 if (element.hasStatusElement()) { 4497 composeEnum(t, "CareTeam", "status", element.getStatusElement(), -1); 4498 } 4499 for (int i = 0; i < element.getCategory().size(); i++) { 4500 composeCodeableConcept(t, "CareTeam", "category", element.getCategory().get(i), i); 4501 } 4502 if (element.hasNameElement()) { 4503 composeString(t, "CareTeam", "name", element.getNameElement(), -1); 4504 } 4505 if (element.hasSubject()) { 4506 composeReference(t, "CareTeam", "subject", element.getSubject(), -1); 4507 } 4508 if (element.hasPeriod()) { 4509 composePeriod(t, "CareTeam", "period", element.getPeriod(), -1); 4510 } 4511 for (int i = 0; i < element.getParticipant().size(); i++) { 4512 composeCareTeamParticipantComponent(t, "CareTeam", "participant", element.getParticipant().get(i), i); 4513 } 4514 for (int i = 0; i < element.getReason().size(); i++) { 4515 composeCodeableReference(t, "CareTeam", "reason", element.getReason().get(i), i); 4516 } 4517 for (int i = 0; i < element.getManagingOrganization().size(); i++) { 4518 composeReference(t, "CareTeam", "managingOrganization", element.getManagingOrganization().get(i), i); 4519 } 4520 for (int i = 0; i < element.getTelecom().size(); i++) { 4521 composeContactPoint(t, "CareTeam", "telecom", element.getTelecom().get(i), i); 4522 } 4523 for (int i = 0; i < element.getNote().size(); i++) { 4524 composeAnnotation(t, "CareTeam", "note", element.getNote().get(i), i); 4525 } 4526 } 4527 4528 protected void composeCareTeamParticipantComponent(Complex parent, String parentType, String name, CareTeam.CareTeamParticipantComponent element, int index) { 4529 if (element == null) 4530 return; 4531 Complex t; 4532 if (Utilities.noString(parentType)) 4533 t = parent; 4534 else { 4535 t = parent.predicate("fhir:"+name,index > -1); 4536 } 4537 composeBackboneElement(t, "participant", name, element, index); 4538 if (element.hasRole()) { 4539 composeCodeableConcept(t, "CareTeamParticipantComponent", "role", element.getRole(), -1); 4540 } 4541 if (element.hasMember()) { 4542 composeReference(t, "CareTeamParticipantComponent", "member", element.getMember(), -1); 4543 } 4544 if (element.hasOnBehalfOf()) { 4545 composeReference(t, "CareTeamParticipantComponent", "onBehalfOf", element.getOnBehalfOf(), -1); 4546 } 4547 if (element.hasCoverage()) { 4548 composeType(t, "CareTeamParticipantComponent", "coverage", element.getCoverage(), -1); 4549 } 4550 } 4551 4552 protected void composeChargeItem(Complex parent, String parentType, String name, ChargeItem element, int index) { 4553 if (element == null) 4554 return; 4555 Complex t; 4556 if (Utilities.noString(parentType)) 4557 t = parent; 4558 else { 4559 t = parent.predicate("fhir:"+name,index > -1); 4560 } 4561 composeDomainResource(t, "ChargeItem", name, element, index); 4562 for (int i = 0; i < element.getIdentifier().size(); i++) { 4563 composeIdentifier(t, "ChargeItem", "identifier", element.getIdentifier().get(i), i); 4564 } 4565 for (int i = 0; i < element.getDefinitionUri().size(); i++) { 4566 composeUri(t, "ChargeItem", "definitionUri", element.getDefinitionUri().get(i), i); 4567 } 4568 for (int i = 0; i < element.getDefinitionCanonical().size(); i++) { 4569 composeCanonical(t, "ChargeItem", "definitionCanonical", element.getDefinitionCanonical().get(i), i); 4570 } 4571 if (element.hasStatusElement()) { 4572 composeEnum(t, "ChargeItem", "status", element.getStatusElement(), -1); 4573 } 4574 for (int i = 0; i < element.getPartOf().size(); i++) { 4575 composeReference(t, "ChargeItem", "partOf", element.getPartOf().get(i), i); 4576 } 4577 if (element.hasCode()) { 4578 composeCodeableConcept(t, "ChargeItem", "code", element.getCode(), -1); 4579 } 4580 if (element.hasSubject()) { 4581 composeReference(t, "ChargeItem", "subject", element.getSubject(), -1); 4582 } 4583 if (element.hasEncounter()) { 4584 composeReference(t, "ChargeItem", "encounter", element.getEncounter(), -1); 4585 } 4586 if (element.hasOccurrence()) { 4587 composeType(t, "ChargeItem", "occurrence", element.getOccurrence(), -1); 4588 } 4589 for (int i = 0; i < element.getPerformer().size(); i++) { 4590 composeChargeItemPerformerComponent(t, "ChargeItem", "performer", element.getPerformer().get(i), i); 4591 } 4592 if (element.hasPerformingOrganization()) { 4593 composeReference(t, "ChargeItem", "performingOrganization", element.getPerformingOrganization(), -1); 4594 } 4595 if (element.hasRequestingOrganization()) { 4596 composeReference(t, "ChargeItem", "requestingOrganization", element.getRequestingOrganization(), -1); 4597 } 4598 if (element.hasCostCenter()) { 4599 composeReference(t, "ChargeItem", "costCenter", element.getCostCenter(), -1); 4600 } 4601 if (element.hasQuantity()) { 4602 composeQuantity(t, "ChargeItem", "quantity", element.getQuantity(), -1); 4603 } 4604 for (int i = 0; i < element.getBodysite().size(); i++) { 4605 composeCodeableConcept(t, "ChargeItem", "bodysite", element.getBodysite().get(i), i); 4606 } 4607 if (element.hasUnitPriceComponent()) { 4608 composeMonetaryComponent(t, "ChargeItem", "unitPriceComponent", element.getUnitPriceComponent(), -1); 4609 } 4610 if (element.hasTotalPriceComponent()) { 4611 composeMonetaryComponent(t, "ChargeItem", "totalPriceComponent", element.getTotalPriceComponent(), -1); 4612 } 4613 if (element.hasOverrideReason()) { 4614 composeCodeableConcept(t, "ChargeItem", "overrideReason", element.getOverrideReason(), -1); 4615 } 4616 if (element.hasEnterer()) { 4617 composeReference(t, "ChargeItem", "enterer", element.getEnterer(), -1); 4618 } 4619 if (element.hasEnteredDateElement()) { 4620 composeDateTime(t, "ChargeItem", "enteredDate", element.getEnteredDateElement(), -1); 4621 } 4622 for (int i = 0; i < element.getReason().size(); i++) { 4623 composeCodeableConcept(t, "ChargeItem", "reason", element.getReason().get(i), i); 4624 } 4625 for (int i = 0; i < element.getService().size(); i++) { 4626 composeCodeableReference(t, "ChargeItem", "service", element.getService().get(i), i); 4627 } 4628 for (int i = 0; i < element.getProduct().size(); i++) { 4629 composeCodeableReference(t, "ChargeItem", "product", element.getProduct().get(i), i); 4630 } 4631 for (int i = 0; i < element.getAccount().size(); i++) { 4632 composeReference(t, "ChargeItem", "account", element.getAccount().get(i), i); 4633 } 4634 for (int i = 0; i < element.getNote().size(); i++) { 4635 composeAnnotation(t, "ChargeItem", "note", element.getNote().get(i), i); 4636 } 4637 for (int i = 0; i < element.getSupportingInformation().size(); i++) { 4638 composeReference(t, "ChargeItem", "supportingInformation", element.getSupportingInformation().get(i), i); 4639 } 4640 } 4641 4642 protected void composeChargeItemPerformerComponent(Complex parent, String parentType, String name, ChargeItem.ChargeItemPerformerComponent element, int index) { 4643 if (element == null) 4644 return; 4645 Complex t; 4646 if (Utilities.noString(parentType)) 4647 t = parent; 4648 else { 4649 t = parent.predicate("fhir:"+name,index > -1); 4650 } 4651 composeBackboneElement(t, "performer", name, element, index); 4652 if (element.hasFunction()) { 4653 composeCodeableConcept(t, "ChargeItemPerformerComponent", "function", element.getFunction(), -1); 4654 } 4655 if (element.hasActor()) { 4656 composeReference(t, "ChargeItemPerformerComponent", "actor", element.getActor(), -1); 4657 } 4658 } 4659 4660 protected void composeChargeItemDefinition(Complex parent, String parentType, String name, ChargeItemDefinition element, int index) { 4661 if (element == null) 4662 return; 4663 Complex t; 4664 if (Utilities.noString(parentType)) 4665 t = parent; 4666 else { 4667 t = parent.predicate("fhir:"+name,index > -1); 4668 } 4669 composeMetadataResource(t, "ChargeItemDefinition", name, element, index); 4670 if (element.hasUrlElement()) { 4671 composeUri(t, "ChargeItemDefinition", "url", element.getUrlElement(), -1); 4672 } 4673 for (int i = 0; i < element.getIdentifier().size(); i++) { 4674 composeIdentifier(t, "ChargeItemDefinition", "identifier", element.getIdentifier().get(i), i); 4675 } 4676 if (element.hasVersionElement()) { 4677 composeString(t, "ChargeItemDefinition", "version", element.getVersionElement(), -1); 4678 } 4679 if (element.hasVersionAlgorithm()) { 4680 composeType(t, "ChargeItemDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1); 4681 } 4682 if (element.hasNameElement()) { 4683 composeString(t, "ChargeItemDefinition", "name", element.getNameElement(), -1); 4684 } 4685 if (element.hasTitleElement()) { 4686 composeString(t, "ChargeItemDefinition", "title", element.getTitleElement(), -1); 4687 } 4688 for (int i = 0; i < element.getDerivedFromUri().size(); i++) { 4689 composeUri(t, "ChargeItemDefinition", "derivedFromUri", element.getDerivedFromUri().get(i), i); 4690 } 4691 for (int i = 0; i < element.getPartOf().size(); i++) { 4692 composeCanonical(t, "ChargeItemDefinition", "partOf", element.getPartOf().get(i), i); 4693 } 4694 for (int i = 0; i < element.getReplaces().size(); i++) { 4695 composeCanonical(t, "ChargeItemDefinition", "replaces", element.getReplaces().get(i), i); 4696 } 4697 if (element.hasStatusElement()) { 4698 composeEnum(t, "ChargeItemDefinition", "status", element.getStatusElement(), -1); 4699 } 4700 if (element.hasExperimentalElement()) { 4701 composeBoolean(t, "ChargeItemDefinition", "experimental", element.getExperimentalElement(), -1); 4702 } 4703 if (element.hasDateElement()) { 4704 composeDateTime(t, "ChargeItemDefinition", "date", element.getDateElement(), -1); 4705 } 4706 if (element.hasPublisherElement()) { 4707 composeString(t, "ChargeItemDefinition", "publisher", element.getPublisherElement(), -1); 4708 } 4709 for (int i = 0; i < element.getContact().size(); i++) { 4710 composeContactDetail(t, "ChargeItemDefinition", "contact", element.getContact().get(i), i); 4711 } 4712 if (element.hasDescriptionElement()) { 4713 composeMarkdown(t, "ChargeItemDefinition", "description", element.getDescriptionElement(), -1); 4714 } 4715 for (int i = 0; i < element.getUseContext().size(); i++) { 4716 composeUsageContext(t, "ChargeItemDefinition", "useContext", element.getUseContext().get(i), i); 4717 } 4718 for (int i = 0; i < element.getJurisdiction().size(); i++) { 4719 composeCodeableConcept(t, "ChargeItemDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 4720 } 4721 if (element.hasPurposeElement()) { 4722 composeMarkdown(t, "ChargeItemDefinition", "purpose", element.getPurposeElement(), -1); 4723 } 4724 if (element.hasCopyrightElement()) { 4725 composeMarkdown(t, "ChargeItemDefinition", "copyright", element.getCopyrightElement(), -1); 4726 } 4727 if (element.hasCopyrightLabelElement()) { 4728 composeString(t, "ChargeItemDefinition", "copyrightLabel", element.getCopyrightLabelElement(), -1); 4729 } 4730 if (element.hasApprovalDateElement()) { 4731 composeDate(t, "ChargeItemDefinition", "approvalDate", element.getApprovalDateElement(), -1); 4732 } 4733 if (element.hasLastReviewDateElement()) { 4734 composeDate(t, "ChargeItemDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 4735 } 4736 if (element.hasCode()) { 4737 composeCodeableConcept(t, "ChargeItemDefinition", "code", element.getCode(), -1); 4738 } 4739 for (int i = 0; i < element.getInstance().size(); i++) { 4740 composeReference(t, "ChargeItemDefinition", "instance", element.getInstance().get(i), i); 4741 } 4742 for (int i = 0; i < element.getApplicability().size(); i++) { 4743 composeChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinition", "applicability", element.getApplicability().get(i), i); 4744 } 4745 for (int i = 0; i < element.getPropertyGroup().size(); i++) { 4746 composeChargeItemDefinitionPropertyGroupComponent(t, "ChargeItemDefinition", "propertyGroup", element.getPropertyGroup().get(i), i); 4747 } 4748 } 4749 4750 protected void composeChargeItemDefinitionApplicabilityComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionApplicabilityComponent element, int index) { 4751 if (element == null) 4752 return; 4753 Complex t; 4754 if (Utilities.noString(parentType)) 4755 t = parent; 4756 else { 4757 t = parent.predicate("fhir:"+name,index > -1); 4758 } 4759 composeBackboneElement(t, "applicability", name, element, index); 4760 if (element.hasCondition()) { 4761 composeExpression(t, "ChargeItemDefinitionApplicabilityComponent", "condition", element.getCondition(), -1); 4762 } 4763 if (element.hasEffectivePeriod()) { 4764 composePeriod(t, "ChargeItemDefinitionApplicabilityComponent", "effectivePeriod", element.getEffectivePeriod(), -1); 4765 } 4766 if (element.hasRelatedArtifact()) { 4767 composeRelatedArtifact(t, "ChargeItemDefinitionApplicabilityComponent", "relatedArtifact", element.getRelatedArtifact(), -1); 4768 } 4769 } 4770 4771 protected void composeChargeItemDefinitionPropertyGroupComponent(Complex parent, String parentType, String name, ChargeItemDefinition.ChargeItemDefinitionPropertyGroupComponent element, int index) { 4772 if (element == null) 4773 return; 4774 Complex t; 4775 if (Utilities.noString(parentType)) 4776 t = parent; 4777 else { 4778 t = parent.predicate("fhir:"+name,index > -1); 4779 } 4780 composeBackboneElement(t, "propertyGroup", name, element, index); 4781 for (int i = 0; i < element.getApplicability().size(); i++) { 4782 composeChargeItemDefinitionApplicabilityComponent(t, "ChargeItemDefinitionPropertyGroupComponent", "applicability", element.getApplicability().get(i), i); 4783 } 4784 for (int i = 0; i < element.getPriceComponent().size(); i++) { 4785 composeMonetaryComponent(t, "ChargeItemDefinitionPropertyGroupComponent", "priceComponent", element.getPriceComponent().get(i), i); 4786 } 4787 } 4788 4789 protected void composeCitation(Complex parent, String parentType, String name, Citation element, int index) { 4790 if (element == null) 4791 return; 4792 Complex t; 4793 if (Utilities.noString(parentType)) 4794 t = parent; 4795 else { 4796 t = parent.predicate("fhir:"+name,index > -1); 4797 } 4798 composeMetadataResource(t, "Citation", name, element, index); 4799 if (element.hasUrlElement()) { 4800 composeUri(t, "Citation", "url", element.getUrlElement(), -1); 4801 } 4802 for (int i = 0; i < element.getIdentifier().size(); i++) { 4803 composeIdentifier(t, "Citation", "identifier", element.getIdentifier().get(i), i); 4804 } 4805 if (element.hasVersionElement()) { 4806 composeString(t, "Citation", "version", element.getVersionElement(), -1); 4807 } 4808 if (element.hasVersionAlgorithm()) { 4809 composeType(t, "Citation", "versionAlgorithm", element.getVersionAlgorithm(), -1); 4810 } 4811 if (element.hasNameElement()) { 4812 composeString(t, "Citation", "name", element.getNameElement(), -1); 4813 } 4814 if (element.hasTitleElement()) { 4815 composeString(t, "Citation", "title", element.getTitleElement(), -1); 4816 } 4817 if (element.hasStatusElement()) { 4818 composeEnum(t, "Citation", "status", element.getStatusElement(), -1); 4819 } 4820 if (element.hasExperimentalElement()) { 4821 composeBoolean(t, "Citation", "experimental", element.getExperimentalElement(), -1); 4822 } 4823 if (element.hasDateElement()) { 4824 composeDateTime(t, "Citation", "date", element.getDateElement(), -1); 4825 } 4826 if (element.hasPublisherElement()) { 4827 composeString(t, "Citation", "publisher", element.getPublisherElement(), -1); 4828 } 4829 for (int i = 0; i < element.getContact().size(); i++) { 4830 composeContactDetail(t, "Citation", "contact", element.getContact().get(i), i); 4831 } 4832 if (element.hasDescriptionElement()) { 4833 composeMarkdown(t, "Citation", "description", element.getDescriptionElement(), -1); 4834 } 4835 for (int i = 0; i < element.getUseContext().size(); i++) { 4836 composeUsageContext(t, "Citation", "useContext", element.getUseContext().get(i), i); 4837 } 4838 for (int i = 0; i < element.getJurisdiction().size(); i++) { 4839 composeCodeableConcept(t, "Citation", "jurisdiction", element.getJurisdiction().get(i), i); 4840 } 4841 if (element.hasPurposeElement()) { 4842 composeMarkdown(t, "Citation", "purpose", element.getPurposeElement(), -1); 4843 } 4844 if (element.hasCopyrightElement()) { 4845 composeMarkdown(t, "Citation", "copyright", element.getCopyrightElement(), -1); 4846 } 4847 if (element.hasCopyrightLabelElement()) { 4848 composeString(t, "Citation", "copyrightLabel", element.getCopyrightLabelElement(), -1); 4849 } 4850 if (element.hasApprovalDateElement()) { 4851 composeDate(t, "Citation", "approvalDate", element.getApprovalDateElement(), -1); 4852 } 4853 if (element.hasLastReviewDateElement()) { 4854 composeDate(t, "Citation", "lastReviewDate", element.getLastReviewDateElement(), -1); 4855 } 4856 if (element.hasEffectivePeriod()) { 4857 composePeriod(t, "Citation", "effectivePeriod", element.getEffectivePeriod(), -1); 4858 } 4859 for (int i = 0; i < element.getAuthor().size(); i++) { 4860 composeContactDetail(t, "Citation", "author", element.getAuthor().get(i), i); 4861 } 4862 for (int i = 0; i < element.getEditor().size(); i++) { 4863 composeContactDetail(t, "Citation", "editor", element.getEditor().get(i), i); 4864 } 4865 for (int i = 0; i < element.getReviewer().size(); i++) { 4866 composeContactDetail(t, "Citation", "reviewer", element.getReviewer().get(i), i); 4867 } 4868 for (int i = 0; i < element.getEndorser().size(); i++) { 4869 composeContactDetail(t, "Citation", "endorser", element.getEndorser().get(i), i); 4870 } 4871 for (int i = 0; i < element.getSummary().size(); i++) { 4872 composeCitationSummaryComponent(t, "Citation", "summary", element.getSummary().get(i), i); 4873 } 4874 for (int i = 0; i < element.getClassification().size(); i++) { 4875 composeCitationClassificationComponent(t, "Citation", "classification", element.getClassification().get(i), i); 4876 } 4877 for (int i = 0; i < element.getNote().size(); i++) { 4878 composeAnnotation(t, "Citation", "note", element.getNote().get(i), i); 4879 } 4880 for (int i = 0; i < element.getCurrentState().size(); i++) { 4881 composeCodeableConcept(t, "Citation", "currentState", element.getCurrentState().get(i), i); 4882 } 4883 for (int i = 0; i < element.getStatusDate().size(); i++) { 4884 composeCitationStatusDateComponent(t, "Citation", "statusDate", element.getStatusDate().get(i), i); 4885 } 4886 for (int i = 0; i < element.getRelatedArtifact().size(); i++) { 4887 composeRelatedArtifact(t, "Citation", "relatedArtifact", element.getRelatedArtifact().get(i), i); 4888 } 4889 if (element.hasCitedArtifact()) { 4890 composeCitationCitedArtifactComponent(t, "Citation", "citedArtifact", element.getCitedArtifact(), -1); 4891 } 4892 } 4893 4894 protected void composeCitationSummaryComponent(Complex parent, String parentType, String name, Citation.CitationSummaryComponent element, int index) { 4895 if (element == null) 4896 return; 4897 Complex t; 4898 if (Utilities.noString(parentType)) 4899 t = parent; 4900 else { 4901 t = parent.predicate("fhir:"+name,index > -1); 4902 } 4903 composeBackboneElement(t, "summary", name, element, index); 4904 if (element.hasStyle()) { 4905 composeCodeableConcept(t, "CitationSummaryComponent", "style", element.getStyle(), -1); 4906 } 4907 if (element.hasTextElement()) { 4908 composeMarkdown(t, "CitationSummaryComponent", "text", element.getTextElement(), -1); 4909 } 4910 } 4911 4912 protected void composeCitationClassificationComponent(Complex parent, String parentType, String name, Citation.CitationClassificationComponent element, int index) { 4913 if (element == null) 4914 return; 4915 Complex t; 4916 if (Utilities.noString(parentType)) 4917 t = parent; 4918 else { 4919 t = parent.predicate("fhir:"+name,index > -1); 4920 } 4921 composeBackboneElement(t, "classification", name, element, index); 4922 if (element.hasType()) { 4923 composeCodeableConcept(t, "CitationClassificationComponent", "type", element.getType(), -1); 4924 } 4925 for (int i = 0; i < element.getClassifier().size(); i++) { 4926 composeCodeableConcept(t, "CitationClassificationComponent", "classifier", element.getClassifier().get(i), i); 4927 } 4928 } 4929 4930 protected void composeCitationStatusDateComponent(Complex parent, String parentType, String name, Citation.CitationStatusDateComponent element, int index) { 4931 if (element == null) 4932 return; 4933 Complex t; 4934 if (Utilities.noString(parentType)) 4935 t = parent; 4936 else { 4937 t = parent.predicate("fhir:"+name,index > -1); 4938 } 4939 composeBackboneElement(t, "statusDate", name, element, index); 4940 if (element.hasActivity()) { 4941 composeCodeableConcept(t, "CitationStatusDateComponent", "activity", element.getActivity(), -1); 4942 } 4943 if (element.hasActualElement()) { 4944 composeBoolean(t, "CitationStatusDateComponent", "actual", element.getActualElement(), -1); 4945 } 4946 if (element.hasPeriod()) { 4947 composePeriod(t, "CitationStatusDateComponent", "period", element.getPeriod(), -1); 4948 } 4949 } 4950 4951 protected void composeCitationCitedArtifactComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactComponent element, int index) { 4952 if (element == null) 4953 return; 4954 Complex t; 4955 if (Utilities.noString(parentType)) 4956 t = parent; 4957 else { 4958 t = parent.predicate("fhir:"+name,index > -1); 4959 } 4960 composeBackboneElement(t, "citedArtifact", name, element, index); 4961 for (int i = 0; i < element.getIdentifier().size(); i++) { 4962 composeIdentifier(t, "CitationCitedArtifactComponent", "identifier", element.getIdentifier().get(i), i); 4963 } 4964 for (int i = 0; i < element.getRelatedIdentifier().size(); i++) { 4965 composeIdentifier(t, "CitationCitedArtifactComponent", "relatedIdentifier", element.getRelatedIdentifier().get(i), i); 4966 } 4967 if (element.hasDateAccessedElement()) { 4968 composeDateTime(t, "CitationCitedArtifactComponent", "dateAccessed", element.getDateAccessedElement(), -1); 4969 } 4970 if (element.hasVersion()) { 4971 composeCitationCitedArtifactVersionComponent(t, "CitationCitedArtifactComponent", "version", element.getVersion(), -1); 4972 } 4973 for (int i = 0; i < element.getCurrentState().size(); i++) { 4974 composeCodeableConcept(t, "CitationCitedArtifactComponent", "currentState", element.getCurrentState().get(i), i); 4975 } 4976 for (int i = 0; i < element.getStatusDate().size(); i++) { 4977 composeCitationCitedArtifactStatusDateComponent(t, "CitationCitedArtifactComponent", "statusDate", element.getStatusDate().get(i), i); 4978 } 4979 for (int i = 0; i < element.getTitle().size(); i++) { 4980 composeCitationCitedArtifactTitleComponent(t, "CitationCitedArtifactComponent", "title", element.getTitle().get(i), i); 4981 } 4982 for (int i = 0; i < element.getAbstract().size(); i++) { 4983 composeCitationCitedArtifactAbstractComponent(t, "CitationCitedArtifactComponent", "abstract", element.getAbstract().get(i), i); 4984 } 4985 if (element.hasPart()) { 4986 composeCitationCitedArtifactPartComponent(t, "CitationCitedArtifactComponent", "part", element.getPart(), -1); 4987 } 4988 for (int i = 0; i < element.getRelatesTo().size(); i++) { 4989 composeCitationCitedArtifactRelatesToComponent(t, "CitationCitedArtifactComponent", "relatesTo", element.getRelatesTo().get(i), i); 4990 } 4991 for (int i = 0; i < element.getPublicationForm().size(); i++) { 4992 composeCitationCitedArtifactPublicationFormComponent(t, "CitationCitedArtifactComponent", "publicationForm", element.getPublicationForm().get(i), i); 4993 } 4994 for (int i = 0; i < element.getWebLocation().size(); i++) { 4995 composeCitationCitedArtifactWebLocationComponent(t, "CitationCitedArtifactComponent", "webLocation", element.getWebLocation().get(i), i); 4996 } 4997 for (int i = 0; i < element.getClassification().size(); i++) { 4998 composeCitationCitedArtifactClassificationComponent(t, "CitationCitedArtifactComponent", "classification", element.getClassification().get(i), i); 4999 } 5000 if (element.hasContributorship()) { 5001 composeCitationCitedArtifactContributorshipComponent(t, "CitationCitedArtifactComponent", "contributorship", element.getContributorship(), -1); 5002 } 5003 for (int i = 0; i < element.getNote().size(); i++) { 5004 composeAnnotation(t, "CitationCitedArtifactComponent", "note", element.getNote().get(i), i); 5005 } 5006 } 5007 5008 protected void composeCitationCitedArtifactVersionComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactVersionComponent element, int index) { 5009 if (element == null) 5010 return; 5011 Complex t; 5012 if (Utilities.noString(parentType)) 5013 t = parent; 5014 else { 5015 t = parent.predicate("fhir:"+name,index > -1); 5016 } 5017 composeBackboneElement(t, "version", name, element, index); 5018 if (element.hasValueElement()) { 5019 composeString(t, "CitationCitedArtifactVersionComponent", "value", element.getValueElement(), -1); 5020 } 5021 if (element.hasBaseCitation()) { 5022 composeReference(t, "CitationCitedArtifactVersionComponent", "baseCitation", element.getBaseCitation(), -1); 5023 } 5024 } 5025 5026 protected void composeCitationCitedArtifactStatusDateComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactStatusDateComponent element, int index) { 5027 if (element == null) 5028 return; 5029 Complex t; 5030 if (Utilities.noString(parentType)) 5031 t = parent; 5032 else { 5033 t = parent.predicate("fhir:"+name,index > -1); 5034 } 5035 composeBackboneElement(t, "statusDate", name, element, index); 5036 if (element.hasActivity()) { 5037 composeCodeableConcept(t, "CitationCitedArtifactStatusDateComponent", "activity", element.getActivity(), -1); 5038 } 5039 if (element.hasActualElement()) { 5040 composeBoolean(t, "CitationCitedArtifactStatusDateComponent", "actual", element.getActualElement(), -1); 5041 } 5042 if (element.hasPeriod()) { 5043 composePeriod(t, "CitationCitedArtifactStatusDateComponent", "period", element.getPeriod(), -1); 5044 } 5045 } 5046 5047 protected void composeCitationCitedArtifactTitleComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactTitleComponent element, int index) { 5048 if (element == null) 5049 return; 5050 Complex t; 5051 if (Utilities.noString(parentType)) 5052 t = parent; 5053 else { 5054 t = parent.predicate("fhir:"+name,index > -1); 5055 } 5056 composeBackboneElement(t, "title", name, element, index); 5057 for (int i = 0; i < element.getType().size(); i++) { 5058 composeCodeableConcept(t, "CitationCitedArtifactTitleComponent", "type", element.getType().get(i), i); 5059 } 5060 if (element.hasLanguage()) { 5061 composeCodeableConcept(t, "CitationCitedArtifactTitleComponent", "language", element.getLanguage(), -1); 5062 } 5063 if (element.hasTextElement()) { 5064 composeMarkdown(t, "CitationCitedArtifactTitleComponent", "text", element.getTextElement(), -1); 5065 } 5066 } 5067 5068 protected void composeCitationCitedArtifactAbstractComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactAbstractComponent element, int index) { 5069 if (element == null) 5070 return; 5071 Complex t; 5072 if (Utilities.noString(parentType)) 5073 t = parent; 5074 else { 5075 t = parent.predicate("fhir:"+name,index > -1); 5076 } 5077 composeBackboneElement(t, "abstract", name, element, index); 5078 if (element.hasType()) { 5079 composeCodeableConcept(t, "CitationCitedArtifactAbstractComponent", "type", element.getType(), -1); 5080 } 5081 if (element.hasLanguage()) { 5082 composeCodeableConcept(t, "CitationCitedArtifactAbstractComponent", "language", element.getLanguage(), -1); 5083 } 5084 if (element.hasTextElement()) { 5085 composeMarkdown(t, "CitationCitedArtifactAbstractComponent", "text", element.getTextElement(), -1); 5086 } 5087 if (element.hasCopyrightElement()) { 5088 composeMarkdown(t, "CitationCitedArtifactAbstractComponent", "copyright", element.getCopyrightElement(), -1); 5089 } 5090 } 5091 5092 protected void composeCitationCitedArtifactPartComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactPartComponent element, int index) { 5093 if (element == null) 5094 return; 5095 Complex t; 5096 if (Utilities.noString(parentType)) 5097 t = parent; 5098 else { 5099 t = parent.predicate("fhir:"+name,index > -1); 5100 } 5101 composeBackboneElement(t, "part", name, element, index); 5102 if (element.hasType()) { 5103 composeCodeableConcept(t, "CitationCitedArtifactPartComponent", "type", element.getType(), -1); 5104 } 5105 if (element.hasValueElement()) { 5106 composeString(t, "CitationCitedArtifactPartComponent", "value", element.getValueElement(), -1); 5107 } 5108 if (element.hasBaseCitation()) { 5109 composeReference(t, "CitationCitedArtifactPartComponent", "baseCitation", element.getBaseCitation(), -1); 5110 } 5111 } 5112 5113 protected void composeCitationCitedArtifactRelatesToComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactRelatesToComponent element, int index) { 5114 if (element == null) 5115 return; 5116 Complex t; 5117 if (Utilities.noString(parentType)) 5118 t = parent; 5119 else { 5120 t = parent.predicate("fhir:"+name,index > -1); 5121 } 5122 composeBackboneElement(t, "relatesTo", name, element, index); 5123 if (element.hasTypeElement()) { 5124 composeEnum(t, "CitationCitedArtifactRelatesToComponent", "type", element.getTypeElement(), -1); 5125 } 5126 for (int i = 0; i < element.getClassifier().size(); i++) { 5127 composeCodeableConcept(t, "CitationCitedArtifactRelatesToComponent", "classifier", element.getClassifier().get(i), i); 5128 } 5129 if (element.hasLabelElement()) { 5130 composeString(t, "CitationCitedArtifactRelatesToComponent", "label", element.getLabelElement(), -1); 5131 } 5132 if (element.hasDisplayElement()) { 5133 composeString(t, "CitationCitedArtifactRelatesToComponent", "display", element.getDisplayElement(), -1); 5134 } 5135 if (element.hasCitationElement()) { 5136 composeMarkdown(t, "CitationCitedArtifactRelatesToComponent", "citation", element.getCitationElement(), -1); 5137 } 5138 if (element.hasDocument()) { 5139 composeAttachment(t, "CitationCitedArtifactRelatesToComponent", "document", element.getDocument(), -1); 5140 } 5141 if (element.hasResourceElement()) { 5142 composeCanonical(t, "CitationCitedArtifactRelatesToComponent", "resource", element.getResourceElement(), -1); 5143 } 5144 if (element.hasResourceReference()) { 5145 composeReference(t, "CitationCitedArtifactRelatesToComponent", "resourceReference", element.getResourceReference(), -1); 5146 } 5147 } 5148 5149 protected void composeCitationCitedArtifactPublicationFormComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactPublicationFormComponent element, int index) { 5150 if (element == null) 5151 return; 5152 Complex t; 5153 if (Utilities.noString(parentType)) 5154 t = parent; 5155 else { 5156 t = parent.predicate("fhir:"+name,index > -1); 5157 } 5158 composeBackboneElement(t, "publicationForm", name, element, index); 5159 if (element.hasPublishedIn()) { 5160 composeCitationCitedArtifactPublicationFormPublishedInComponent(t, "CitationCitedArtifactPublicationFormComponent", "publishedIn", element.getPublishedIn(), -1); 5161 } 5162 if (element.hasCitedMedium()) { 5163 composeCodeableConcept(t, "CitationCitedArtifactPublicationFormComponent", "citedMedium", element.getCitedMedium(), -1); 5164 } 5165 if (element.hasVolumeElement()) { 5166 composeString(t, "CitationCitedArtifactPublicationFormComponent", "volume", element.getVolumeElement(), -1); 5167 } 5168 if (element.hasIssueElement()) { 5169 composeString(t, "CitationCitedArtifactPublicationFormComponent", "issue", element.getIssueElement(), -1); 5170 } 5171 if (element.hasArticleDateElement()) { 5172 composeDateTime(t, "CitationCitedArtifactPublicationFormComponent", "articleDate", element.getArticleDateElement(), -1); 5173 } 5174 if (element.hasPublicationDateTextElement()) { 5175 composeString(t, "CitationCitedArtifactPublicationFormComponent", "publicationDateText", element.getPublicationDateTextElement(), -1); 5176 } 5177 if (element.hasPublicationDateSeasonElement()) { 5178 composeString(t, "CitationCitedArtifactPublicationFormComponent", "publicationDateSeason", element.getPublicationDateSeasonElement(), -1); 5179 } 5180 if (element.hasLastRevisionDateElement()) { 5181 composeDateTime(t, "CitationCitedArtifactPublicationFormComponent", "lastRevisionDate", element.getLastRevisionDateElement(), -1); 5182 } 5183 for (int i = 0; i < element.getLanguage().size(); i++) { 5184 composeCodeableConcept(t, "CitationCitedArtifactPublicationFormComponent", "language", element.getLanguage().get(i), i); 5185 } 5186 if (element.hasAccessionNumberElement()) { 5187 composeString(t, "CitationCitedArtifactPublicationFormComponent", "accessionNumber", element.getAccessionNumberElement(), -1); 5188 } 5189 if (element.hasPageStringElement()) { 5190 composeString(t, "CitationCitedArtifactPublicationFormComponent", "pageString", element.getPageStringElement(), -1); 5191 } 5192 if (element.hasFirstPageElement()) { 5193 composeString(t, "CitationCitedArtifactPublicationFormComponent", "firstPage", element.getFirstPageElement(), -1); 5194 } 5195 if (element.hasLastPageElement()) { 5196 composeString(t, "CitationCitedArtifactPublicationFormComponent", "lastPage", element.getLastPageElement(), -1); 5197 } 5198 if (element.hasPageCountElement()) { 5199 composeString(t, "CitationCitedArtifactPublicationFormComponent", "pageCount", element.getPageCountElement(), -1); 5200 } 5201 if (element.hasCopyrightElement()) { 5202 composeMarkdown(t, "CitationCitedArtifactPublicationFormComponent", "copyright", element.getCopyrightElement(), -1); 5203 } 5204 } 5205 5206 protected void composeCitationCitedArtifactPublicationFormPublishedInComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactPublicationFormPublishedInComponent element, int index) { 5207 if (element == null) 5208 return; 5209 Complex t; 5210 if (Utilities.noString(parentType)) 5211 t = parent; 5212 else { 5213 t = parent.predicate("fhir:"+name,index > -1); 5214 } 5215 composeBackboneElement(t, "publishedIn", name, element, index); 5216 if (element.hasType()) { 5217 composeCodeableConcept(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "type", element.getType(), -1); 5218 } 5219 for (int i = 0; i < element.getIdentifier().size(); i++) { 5220 composeIdentifier(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "identifier", element.getIdentifier().get(i), i); 5221 } 5222 if (element.hasTitleElement()) { 5223 composeString(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "title", element.getTitleElement(), -1); 5224 } 5225 if (element.hasPublisher()) { 5226 composeReference(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "publisher", element.getPublisher(), -1); 5227 } 5228 if (element.hasPublisherLocationElement()) { 5229 composeString(t, "CitationCitedArtifactPublicationFormPublishedInComponent", "publisherLocation", element.getPublisherLocationElement(), -1); 5230 } 5231 } 5232 5233 protected void composeCitationCitedArtifactWebLocationComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactWebLocationComponent element, int index) { 5234 if (element == null) 5235 return; 5236 Complex t; 5237 if (Utilities.noString(parentType)) 5238 t = parent; 5239 else { 5240 t = parent.predicate("fhir:"+name,index > -1); 5241 } 5242 composeBackboneElement(t, "webLocation", name, element, index); 5243 for (int i = 0; i < element.getClassifier().size(); i++) { 5244 composeCodeableConcept(t, "CitationCitedArtifactWebLocationComponent", "classifier", element.getClassifier().get(i), i); 5245 } 5246 if (element.hasUrlElement()) { 5247 composeUri(t, "CitationCitedArtifactWebLocationComponent", "url", element.getUrlElement(), -1); 5248 } 5249 } 5250 5251 protected void composeCitationCitedArtifactClassificationComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactClassificationComponent element, int index) { 5252 if (element == null) 5253 return; 5254 Complex t; 5255 if (Utilities.noString(parentType)) 5256 t = parent; 5257 else { 5258 t = parent.predicate("fhir:"+name,index > -1); 5259 } 5260 composeBackboneElement(t, "classification", name, element, index); 5261 if (element.hasType()) { 5262 composeCodeableConcept(t, "CitationCitedArtifactClassificationComponent", "type", element.getType(), -1); 5263 } 5264 for (int i = 0; i < element.getClassifier().size(); i++) { 5265 composeCodeableConcept(t, "CitationCitedArtifactClassificationComponent", "classifier", element.getClassifier().get(i), i); 5266 } 5267 for (int i = 0; i < element.getArtifactAssessment().size(); i++) { 5268 composeReference(t, "CitationCitedArtifactClassificationComponent", "artifactAssessment", element.getArtifactAssessment().get(i), i); 5269 } 5270 } 5271 5272 protected void composeCitationCitedArtifactContributorshipComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactContributorshipComponent element, int index) { 5273 if (element == null) 5274 return; 5275 Complex t; 5276 if (Utilities.noString(parentType)) 5277 t = parent; 5278 else { 5279 t = parent.predicate("fhir:"+name,index > -1); 5280 } 5281 composeBackboneElement(t, "contributorship", name, element, index); 5282 if (element.hasCompleteElement()) { 5283 composeBoolean(t, "CitationCitedArtifactContributorshipComponent", "complete", element.getCompleteElement(), -1); 5284 } 5285 for (int i = 0; i < element.getEntry().size(); i++) { 5286 composeCitationCitedArtifactContributorshipEntryComponent(t, "CitationCitedArtifactContributorshipComponent", "entry", element.getEntry().get(i), i); 5287 } 5288 for (int i = 0; i < element.getSummary().size(); i++) { 5289 composeCitationContributorshipSummaryComponent(t, "CitationCitedArtifactContributorshipComponent", "summary", element.getSummary().get(i), i); 5290 } 5291 } 5292 5293 protected void composeCitationCitedArtifactContributorshipEntryComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactContributorshipEntryComponent element, int index) { 5294 if (element == null) 5295 return; 5296 Complex t; 5297 if (Utilities.noString(parentType)) 5298 t = parent; 5299 else { 5300 t = parent.predicate("fhir:"+name,index > -1); 5301 } 5302 composeBackboneElement(t, "entry", name, element, index); 5303 if (element.hasContributor()) { 5304 composeReference(t, "CitationCitedArtifactContributorshipEntryComponent", "contributor", element.getContributor(), -1); 5305 } 5306 if (element.hasForenameInitialsElement()) { 5307 composeString(t, "CitationCitedArtifactContributorshipEntryComponent", "forenameInitials", element.getForenameInitialsElement(), -1); 5308 } 5309 for (int i = 0; i < element.getAffiliation().size(); i++) { 5310 composeReference(t, "CitationCitedArtifactContributorshipEntryComponent", "affiliation", element.getAffiliation().get(i), i); 5311 } 5312 for (int i = 0; i < element.getContributionType().size(); i++) { 5313 composeCodeableConcept(t, "CitationCitedArtifactContributorshipEntryComponent", "contributionType", element.getContributionType().get(i), i); 5314 } 5315 if (element.hasRole()) { 5316 composeCodeableConcept(t, "CitationCitedArtifactContributorshipEntryComponent", "role", element.getRole(), -1); 5317 } 5318 for (int i = 0; i < element.getContributionInstance().size(); i++) { 5319 composeCitationCitedArtifactContributorshipEntryContributionInstanceComponent(t, "CitationCitedArtifactContributorshipEntryComponent", "contributionInstance", element.getContributionInstance().get(i), i); 5320 } 5321 if (element.hasCorrespondingContactElement()) { 5322 composeBoolean(t, "CitationCitedArtifactContributorshipEntryComponent", "correspondingContact", element.getCorrespondingContactElement(), -1); 5323 } 5324 if (element.hasRankingOrderElement()) { 5325 composePositiveInt(t, "CitationCitedArtifactContributorshipEntryComponent", "rankingOrder", element.getRankingOrderElement(), -1); 5326 } 5327 } 5328 5329 protected void composeCitationCitedArtifactContributorshipEntryContributionInstanceComponent(Complex parent, String parentType, String name, Citation.CitationCitedArtifactContributorshipEntryContributionInstanceComponent element, int index) { 5330 if (element == null) 5331 return; 5332 Complex t; 5333 if (Utilities.noString(parentType)) 5334 t = parent; 5335 else { 5336 t = parent.predicate("fhir:"+name,index > -1); 5337 } 5338 composeBackboneElement(t, "contributionInstance", name, element, index); 5339 if (element.hasType()) { 5340 composeCodeableConcept(t, "CitationCitedArtifactContributorshipEntryContributionInstanceComponent", "type", element.getType(), -1); 5341 } 5342 if (element.hasTimeElement()) { 5343 composeDateTime(t, "CitationCitedArtifactContributorshipEntryContributionInstanceComponent", "time", element.getTimeElement(), -1); 5344 } 5345 } 5346 5347 protected void composeCitationContributorshipSummaryComponent(Complex parent, String parentType, String name, Citation.ContributorshipSummaryComponent element, int index) { 5348 if (element == null) 5349 return; 5350 Complex t; 5351 if (Utilities.noString(parentType)) 5352 t = parent; 5353 else { 5354 t = parent.predicate("fhir:"+name,index > -1); 5355 } 5356 composeBackboneElement(t, "summary", name, element, index); 5357 if (element.hasType()) { 5358 composeCodeableConcept(t, "ContributorshipSummaryComponent", "type", element.getType(), -1); 5359 } 5360 if (element.hasStyle()) { 5361 composeCodeableConcept(t, "ContributorshipSummaryComponent", "style", element.getStyle(), -1); 5362 } 5363 if (element.hasSource()) { 5364 composeCodeableConcept(t, "ContributorshipSummaryComponent", "source", element.getSource(), -1); 5365 } 5366 if (element.hasValueElement()) { 5367 composeMarkdown(t, "ContributorshipSummaryComponent", "value", element.getValueElement(), -1); 5368 } 5369 } 5370 5371 protected void composeClaim(Complex parent, String parentType, String name, Claim element, int index) { 5372 if (element == null) 5373 return; 5374 Complex t; 5375 if (Utilities.noString(parentType)) 5376 t = parent; 5377 else { 5378 t = parent.predicate("fhir:"+name,index > -1); 5379 } 5380 composeDomainResource(t, "Claim", name, element, index); 5381 for (int i = 0; i < element.getIdentifier().size(); i++) { 5382 composeIdentifier(t, "Claim", "identifier", element.getIdentifier().get(i), i); 5383 } 5384 for (int i = 0; i < element.getTraceNumber().size(); i++) { 5385 composeIdentifier(t, "Claim", "traceNumber", element.getTraceNumber().get(i), i); 5386 } 5387 if (element.hasStatusElement()) { 5388 composeEnum(t, "Claim", "status", element.getStatusElement(), -1); 5389 } 5390 if (element.hasType()) { 5391 composeCodeableConcept(t, "Claim", "type", element.getType(), -1); 5392 } 5393 if (element.hasSubType()) { 5394 composeCodeableConcept(t, "Claim", "subType", element.getSubType(), -1); 5395 } 5396 if (element.hasUseElement()) { 5397 composeEnum(t, "Claim", "use", element.getUseElement(), -1); 5398 } 5399 if (element.hasPatient()) { 5400 composeReference(t, "Claim", "patient", element.getPatient(), -1); 5401 } 5402 if (element.hasBillablePeriod()) { 5403 composePeriod(t, "Claim", "billablePeriod", element.getBillablePeriod(), -1); 5404 } 5405 if (element.hasCreatedElement()) { 5406 composeDateTime(t, "Claim", "created", element.getCreatedElement(), -1); 5407 } 5408 if (element.hasEnterer()) { 5409 composeReference(t, "Claim", "enterer", element.getEnterer(), -1); 5410 } 5411 if (element.hasInsurer()) { 5412 composeReference(t, "Claim", "insurer", element.getInsurer(), -1); 5413 } 5414 if (element.hasProvider()) { 5415 composeReference(t, "Claim", "provider", element.getProvider(), -1); 5416 } 5417 if (element.hasPriority()) { 5418 composeCodeableConcept(t, "Claim", "priority", element.getPriority(), -1); 5419 } 5420 if (element.hasFundsReserve()) { 5421 composeCodeableConcept(t, "Claim", "fundsReserve", element.getFundsReserve(), -1); 5422 } 5423 for (int i = 0; i < element.getRelated().size(); i++) { 5424 composeClaimRelatedClaimComponent(t, "Claim", "related", element.getRelated().get(i), i); 5425 } 5426 if (element.hasPrescription()) { 5427 composeReference(t, "Claim", "prescription", element.getPrescription(), -1); 5428 } 5429 if (element.hasOriginalPrescription()) { 5430 composeReference(t, "Claim", "originalPrescription", element.getOriginalPrescription(), -1); 5431 } 5432 if (element.hasPayee()) { 5433 composeClaimPayeeComponent(t, "Claim", "payee", element.getPayee(), -1); 5434 } 5435 if (element.hasReferral()) { 5436 composeReference(t, "Claim", "referral", element.getReferral(), -1); 5437 } 5438 for (int i = 0; i < element.getEncounter().size(); i++) { 5439 composeReference(t, "Claim", "encounter", element.getEncounter().get(i), i); 5440 } 5441 if (element.hasFacility()) { 5442 composeReference(t, "Claim", "facility", element.getFacility(), -1); 5443 } 5444 if (element.hasDiagnosisRelatedGroup()) { 5445 composeCodeableConcept(t, "Claim", "diagnosisRelatedGroup", element.getDiagnosisRelatedGroup(), -1); 5446 } 5447 for (int i = 0; i < element.getEvent().size(); i++) { 5448 composeClaimEventComponent(t, "Claim", "event", element.getEvent().get(i), i); 5449 } 5450 for (int i = 0; i < element.getCareTeam().size(); i++) { 5451 composeClaimCareTeamComponent(t, "Claim", "careTeam", element.getCareTeam().get(i), i); 5452 } 5453 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 5454 composeClaimSupportingInformationComponent(t, "Claim", "supportingInfo", element.getSupportingInfo().get(i), i); 5455 } 5456 for (int i = 0; i < element.getDiagnosis().size(); i++) { 5457 composeClaimDiagnosisComponent(t, "Claim", "diagnosis", element.getDiagnosis().get(i), i); 5458 } 5459 for (int i = 0; i < element.getProcedure().size(); i++) { 5460 composeClaimProcedureComponent(t, "Claim", "procedure", element.getProcedure().get(i), i); 5461 } 5462 for (int i = 0; i < element.getInsurance().size(); i++) { 5463 composeClaimInsuranceComponent(t, "Claim", "insurance", element.getInsurance().get(i), i); 5464 } 5465 if (element.hasAccident()) { 5466 composeClaimAccidentComponent(t, "Claim", "accident", element.getAccident(), -1); 5467 } 5468 if (element.hasPatientPaid()) { 5469 composeMoney(t, "Claim", "patientPaid", element.getPatientPaid(), -1); 5470 } 5471 for (int i = 0; i < element.getItem().size(); i++) { 5472 composeClaimItemComponent(t, "Claim", "item", element.getItem().get(i), i); 5473 } 5474 if (element.hasTotal()) { 5475 composeMoney(t, "Claim", "total", element.getTotal(), -1); 5476 } 5477 } 5478 5479 protected void composeClaimRelatedClaimComponent(Complex parent, String parentType, String name, Claim.RelatedClaimComponent element, int index) { 5480 if (element == null) 5481 return; 5482 Complex t; 5483 if (Utilities.noString(parentType)) 5484 t = parent; 5485 else { 5486 t = parent.predicate("fhir:"+name,index > -1); 5487 } 5488 composeBackboneElement(t, "related", name, element, index); 5489 if (element.hasClaim()) { 5490 composeReference(t, "RelatedClaimComponent", "claim", element.getClaim(), -1); 5491 } 5492 if (element.hasRelationship()) { 5493 composeCodeableConcept(t, "RelatedClaimComponent", "relationship", element.getRelationship(), -1); 5494 } 5495 if (element.hasReference()) { 5496 composeIdentifier(t, "RelatedClaimComponent", "reference", element.getReference(), -1); 5497 } 5498 } 5499 5500 protected void composeClaimPayeeComponent(Complex parent, String parentType, String name, Claim.PayeeComponent element, int index) { 5501 if (element == null) 5502 return; 5503 Complex t; 5504 if (Utilities.noString(parentType)) 5505 t = parent; 5506 else { 5507 t = parent.predicate("fhir:"+name,index > -1); 5508 } 5509 composeBackboneElement(t, "payee", name, element, index); 5510 if (element.hasType()) { 5511 composeCodeableConcept(t, "PayeeComponent", "type", element.getType(), -1); 5512 } 5513 if (element.hasParty()) { 5514 composeReference(t, "PayeeComponent", "party", element.getParty(), -1); 5515 } 5516 } 5517 5518 protected void composeClaimEventComponent(Complex parent, String parentType, String name, Claim.ClaimEventComponent element, int index) { 5519 if (element == null) 5520 return; 5521 Complex t; 5522 if (Utilities.noString(parentType)) 5523 t = parent; 5524 else { 5525 t = parent.predicate("fhir:"+name,index > -1); 5526 } 5527 composeBackboneElement(t, "event", name, element, index); 5528 if (element.hasType()) { 5529 composeCodeableConcept(t, "ClaimEventComponent", "type", element.getType(), -1); 5530 } 5531 if (element.hasWhen()) { 5532 composeType(t, "ClaimEventComponent", "when", element.getWhen(), -1); 5533 } 5534 } 5535 5536 protected void composeClaimCareTeamComponent(Complex parent, String parentType, String name, Claim.CareTeamComponent element, int index) { 5537 if (element == null) 5538 return; 5539 Complex t; 5540 if (Utilities.noString(parentType)) 5541 t = parent; 5542 else { 5543 t = parent.predicate("fhir:"+name,index > -1); 5544 } 5545 composeBackboneElement(t, "careTeam", name, element, index); 5546 if (element.hasSequenceElement()) { 5547 composePositiveInt(t, "CareTeamComponent", "sequence", element.getSequenceElement(), -1); 5548 } 5549 if (element.hasProvider()) { 5550 composeReference(t, "CareTeamComponent", "provider", element.getProvider(), -1); 5551 } 5552 if (element.hasResponsibleElement()) { 5553 composeBoolean(t, "CareTeamComponent", "responsible", element.getResponsibleElement(), -1); 5554 } 5555 if (element.hasRole()) { 5556 composeCodeableConcept(t, "CareTeamComponent", "role", element.getRole(), -1); 5557 } 5558 if (element.hasSpecialty()) { 5559 composeCodeableConcept(t, "CareTeamComponent", "specialty", element.getSpecialty(), -1); 5560 } 5561 } 5562 5563 protected void composeClaimSupportingInformationComponent(Complex parent, String parentType, String name, Claim.SupportingInformationComponent element, int index) { 5564 if (element == null) 5565 return; 5566 Complex t; 5567 if (Utilities.noString(parentType)) 5568 t = parent; 5569 else { 5570 t = parent.predicate("fhir:"+name,index > -1); 5571 } 5572 composeBackboneElement(t, "supportingInfo", name, element, index); 5573 if (element.hasSequenceElement()) { 5574 composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1); 5575 } 5576 if (element.hasCategory()) { 5577 composeCodeableConcept(t, "SupportingInformationComponent", "category", element.getCategory(), -1); 5578 } 5579 if (element.hasCode()) { 5580 composeCodeableConcept(t, "SupportingInformationComponent", "code", element.getCode(), -1); 5581 } 5582 if (element.hasTiming()) { 5583 composeType(t, "SupportingInformationComponent", "timing", element.getTiming(), -1); 5584 } 5585 if (element.hasValue()) { 5586 composeType(t, "SupportingInformationComponent", "value", element.getValue(), -1); 5587 } 5588 if (element.hasReason()) { 5589 composeCodeableConcept(t, "SupportingInformationComponent", "reason", element.getReason(), -1); 5590 } 5591 } 5592 5593 protected void composeClaimDiagnosisComponent(Complex parent, String parentType, String name, Claim.DiagnosisComponent element, int index) { 5594 if (element == null) 5595 return; 5596 Complex t; 5597 if (Utilities.noString(parentType)) 5598 t = parent; 5599 else { 5600 t = parent.predicate("fhir:"+name,index > -1); 5601 } 5602 composeBackboneElement(t, "diagnosis", name, element, index); 5603 if (element.hasSequenceElement()) { 5604 composePositiveInt(t, "DiagnosisComponent", "sequence", element.getSequenceElement(), -1); 5605 } 5606 if (element.hasDiagnosis()) { 5607 composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1); 5608 } 5609 for (int i = 0; i < element.getType().size(); i++) { 5610 composeCodeableConcept(t, "DiagnosisComponent", "type", element.getType().get(i), i); 5611 } 5612 if (element.hasOnAdmission()) { 5613 composeCodeableConcept(t, "DiagnosisComponent", "onAdmission", element.getOnAdmission(), -1); 5614 } 5615 } 5616 5617 protected void composeClaimProcedureComponent(Complex parent, String parentType, String name, Claim.ProcedureComponent element, int index) { 5618 if (element == null) 5619 return; 5620 Complex t; 5621 if (Utilities.noString(parentType)) 5622 t = parent; 5623 else { 5624 t = parent.predicate("fhir:"+name,index > -1); 5625 } 5626 composeBackboneElement(t, "procedure", name, element, index); 5627 if (element.hasSequenceElement()) { 5628 composePositiveInt(t, "ProcedureComponent", "sequence", element.getSequenceElement(), -1); 5629 } 5630 for (int i = 0; i < element.getType().size(); i++) { 5631 composeCodeableConcept(t, "ProcedureComponent", "type", element.getType().get(i), i); 5632 } 5633 if (element.hasDateElement()) { 5634 composeDateTime(t, "ProcedureComponent", "date", element.getDateElement(), -1); 5635 } 5636 if (element.hasProcedure()) { 5637 composeType(t, "ProcedureComponent", "procedure", element.getProcedure(), -1); 5638 } 5639 for (int i = 0; i < element.getUdi().size(); i++) { 5640 composeReference(t, "ProcedureComponent", "udi", element.getUdi().get(i), i); 5641 } 5642 } 5643 5644 protected void composeClaimInsuranceComponent(Complex parent, String parentType, String name, Claim.InsuranceComponent element, int index) { 5645 if (element == null) 5646 return; 5647 Complex t; 5648 if (Utilities.noString(parentType)) 5649 t = parent; 5650 else { 5651 t = parent.predicate("fhir:"+name,index > -1); 5652 } 5653 composeBackboneElement(t, "insurance", name, element, index); 5654 if (element.hasSequenceElement()) { 5655 composePositiveInt(t, "InsuranceComponent", "sequence", element.getSequenceElement(), -1); 5656 } 5657 if (element.hasFocalElement()) { 5658 composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1); 5659 } 5660 if (element.hasIdentifier()) { 5661 composeIdentifier(t, "InsuranceComponent", "identifier", element.getIdentifier(), -1); 5662 } 5663 if (element.hasCoverage()) { 5664 composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1); 5665 } 5666 if (element.hasBusinessArrangementElement()) { 5667 composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1); 5668 } 5669 for (int i = 0; i < element.getPreAuthRef().size(); i++) { 5670 composeString(t, "InsuranceComponent", "preAuthRef", element.getPreAuthRef().get(i), i); 5671 } 5672 if (element.hasClaimResponse()) { 5673 composeReference(t, "InsuranceComponent", "claimResponse", element.getClaimResponse(), -1); 5674 } 5675 } 5676 5677 protected void composeClaimAccidentComponent(Complex parent, String parentType, String name, Claim.AccidentComponent element, int index) { 5678 if (element == null) 5679 return; 5680 Complex t; 5681 if (Utilities.noString(parentType)) 5682 t = parent; 5683 else { 5684 t = parent.predicate("fhir:"+name,index > -1); 5685 } 5686 composeBackboneElement(t, "accident", name, element, index); 5687 if (element.hasDateElement()) { 5688 composeDate(t, "AccidentComponent", "date", element.getDateElement(), -1); 5689 } 5690 if (element.hasType()) { 5691 composeCodeableConcept(t, "AccidentComponent", "type", element.getType(), -1); 5692 } 5693 if (element.hasLocation()) { 5694 composeType(t, "AccidentComponent", "location", element.getLocation(), -1); 5695 } 5696 } 5697 5698 protected void composeClaimItemComponent(Complex parent, String parentType, String name, Claim.ItemComponent element, int index) { 5699 if (element == null) 5700 return; 5701 Complex t; 5702 if (Utilities.noString(parentType)) 5703 t = parent; 5704 else { 5705 t = parent.predicate("fhir:"+name,index > -1); 5706 } 5707 composeBackboneElement(t, "item", name, element, index); 5708 if (element.hasSequenceElement()) { 5709 composePositiveInt(t, "ItemComponent", "sequence", element.getSequenceElement(), -1); 5710 } 5711 for (int i = 0; i < element.getTraceNumber().size(); i++) { 5712 composeIdentifier(t, "ItemComponent", "traceNumber", element.getTraceNumber().get(i), i); 5713 } 5714 for (int i = 0; i < element.getCareTeamSequence().size(); i++) { 5715 composePositiveInt(t, "ItemComponent", "careTeamSequence", element.getCareTeamSequence().get(i), i); 5716 } 5717 for (int i = 0; i < element.getDiagnosisSequence().size(); i++) { 5718 composePositiveInt(t, "ItemComponent", "diagnosisSequence", element.getDiagnosisSequence().get(i), i); 5719 } 5720 for (int i = 0; i < element.getProcedureSequence().size(); i++) { 5721 composePositiveInt(t, "ItemComponent", "procedureSequence", element.getProcedureSequence().get(i), i); 5722 } 5723 for (int i = 0; i < element.getInformationSequence().size(); i++) { 5724 composePositiveInt(t, "ItemComponent", "informationSequence", element.getInformationSequence().get(i), i); 5725 } 5726 if (element.hasRevenue()) { 5727 composeCodeableConcept(t, "ItemComponent", "revenue", element.getRevenue(), -1); 5728 } 5729 if (element.hasCategory()) { 5730 composeCodeableConcept(t, "ItemComponent", "category", element.getCategory(), -1); 5731 } 5732 if (element.hasProductOrService()) { 5733 composeCodeableConcept(t, "ItemComponent", "productOrService", element.getProductOrService(), -1); 5734 } 5735 if (element.hasProductOrServiceEnd()) { 5736 composeCodeableConcept(t, "ItemComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1); 5737 } 5738 for (int i = 0; i < element.getRequest().size(); i++) { 5739 composeReference(t, "ItemComponent", "request", element.getRequest().get(i), i); 5740 } 5741 for (int i = 0; i < element.getModifier().size(); i++) { 5742 composeCodeableConcept(t, "ItemComponent", "modifier", element.getModifier().get(i), i); 5743 } 5744 for (int i = 0; i < element.getProgramCode().size(); i++) { 5745 composeCodeableConcept(t, "ItemComponent", "programCode", element.getProgramCode().get(i), i); 5746 } 5747 if (element.hasServiced()) { 5748 composeType(t, "ItemComponent", "serviced", element.getServiced(), -1); 5749 } 5750 if (element.hasLocation()) { 5751 composeType(t, "ItemComponent", "location", element.getLocation(), -1); 5752 } 5753 if (element.hasPatientPaid()) { 5754 composeMoney(t, "ItemComponent", "patientPaid", element.getPatientPaid(), -1); 5755 } 5756 if (element.hasQuantity()) { 5757 composeQuantity(t, "ItemComponent", "quantity", element.getQuantity(), -1); 5758 } 5759 if (element.hasUnitPrice()) { 5760 composeMoney(t, "ItemComponent", "unitPrice", element.getUnitPrice(), -1); 5761 } 5762 if (element.hasFactorElement()) { 5763 composeDecimal(t, "ItemComponent", "factor", element.getFactorElement(), -1); 5764 } 5765 if (element.hasTax()) { 5766 composeMoney(t, "ItemComponent", "tax", element.getTax(), -1); 5767 } 5768 if (element.hasNet()) { 5769 composeMoney(t, "ItemComponent", "net", element.getNet(), -1); 5770 } 5771 for (int i = 0; i < element.getUdi().size(); i++) { 5772 composeReference(t, "ItemComponent", "udi", element.getUdi().get(i), i); 5773 } 5774 for (int i = 0; i < element.getBodySite().size(); i++) { 5775 composeClaimBodySiteComponent(t, "ItemComponent", "bodySite", element.getBodySite().get(i), i); 5776 } 5777 for (int i = 0; i < element.getEncounter().size(); i++) { 5778 composeReference(t, "ItemComponent", "encounter", element.getEncounter().get(i), i); 5779 } 5780 for (int i = 0; i < element.getDetail().size(); i++) { 5781 composeClaimDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i); 5782 } 5783 } 5784 5785 protected void composeClaimBodySiteComponent(Complex parent, String parentType, String name, Claim.BodySiteComponent element, int index) { 5786 if (element == null) 5787 return; 5788 Complex t; 5789 if (Utilities.noString(parentType)) 5790 t = parent; 5791 else { 5792 t = parent.predicate("fhir:"+name,index > -1); 5793 } 5794 composeBackboneElement(t, "bodySite", name, element, index); 5795 for (int i = 0; i < element.getSite().size(); i++) { 5796 composeCodeableReference(t, "BodySiteComponent", "site", element.getSite().get(i), i); 5797 } 5798 for (int i = 0; i < element.getSubSite().size(); i++) { 5799 composeCodeableConcept(t, "BodySiteComponent", "subSite", element.getSubSite().get(i), i); 5800 } 5801 } 5802 5803 protected void composeClaimDetailComponent(Complex parent, String parentType, String name, Claim.DetailComponent element, int index) { 5804 if (element == null) 5805 return; 5806 Complex t; 5807 if (Utilities.noString(parentType)) 5808 t = parent; 5809 else { 5810 t = parent.predicate("fhir:"+name,index > -1); 5811 } 5812 composeBackboneElement(t, "detail", name, element, index); 5813 if (element.hasSequenceElement()) { 5814 composePositiveInt(t, "DetailComponent", "sequence", element.getSequenceElement(), -1); 5815 } 5816 for (int i = 0; i < element.getTraceNumber().size(); i++) { 5817 composeIdentifier(t, "DetailComponent", "traceNumber", element.getTraceNumber().get(i), i); 5818 } 5819 if (element.hasRevenue()) { 5820 composeCodeableConcept(t, "DetailComponent", "revenue", element.getRevenue(), -1); 5821 } 5822 if (element.hasCategory()) { 5823 composeCodeableConcept(t, "DetailComponent", "category", element.getCategory(), -1); 5824 } 5825 if (element.hasProductOrService()) { 5826 composeCodeableConcept(t, "DetailComponent", "productOrService", element.getProductOrService(), -1); 5827 } 5828 if (element.hasProductOrServiceEnd()) { 5829 composeCodeableConcept(t, "DetailComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1); 5830 } 5831 for (int i = 0; i < element.getModifier().size(); i++) { 5832 composeCodeableConcept(t, "DetailComponent", "modifier", element.getModifier().get(i), i); 5833 } 5834 for (int i = 0; i < element.getProgramCode().size(); i++) { 5835 composeCodeableConcept(t, "DetailComponent", "programCode", element.getProgramCode().get(i), i); 5836 } 5837 if (element.hasPatientPaid()) { 5838 composeMoney(t, "DetailComponent", "patientPaid", element.getPatientPaid(), -1); 5839 } 5840 if (element.hasQuantity()) { 5841 composeQuantity(t, "DetailComponent", "quantity", element.getQuantity(), -1); 5842 } 5843 if (element.hasUnitPrice()) { 5844 composeMoney(t, "DetailComponent", "unitPrice", element.getUnitPrice(), -1); 5845 } 5846 if (element.hasFactorElement()) { 5847 composeDecimal(t, "DetailComponent", "factor", element.getFactorElement(), -1); 5848 } 5849 if (element.hasTax()) { 5850 composeMoney(t, "DetailComponent", "tax", element.getTax(), -1); 5851 } 5852 if (element.hasNet()) { 5853 composeMoney(t, "DetailComponent", "net", element.getNet(), -1); 5854 } 5855 for (int i = 0; i < element.getUdi().size(); i++) { 5856 composeReference(t, "DetailComponent", "udi", element.getUdi().get(i), i); 5857 } 5858 for (int i = 0; i < element.getSubDetail().size(); i++) { 5859 composeClaimSubDetailComponent(t, "DetailComponent", "subDetail", element.getSubDetail().get(i), i); 5860 } 5861 } 5862 5863 protected void composeClaimSubDetailComponent(Complex parent, String parentType, String name, Claim.SubDetailComponent element, int index) { 5864 if (element == null) 5865 return; 5866 Complex t; 5867 if (Utilities.noString(parentType)) 5868 t = parent; 5869 else { 5870 t = parent.predicate("fhir:"+name,index > -1); 5871 } 5872 composeBackboneElement(t, "subDetail", name, element, index); 5873 if (element.hasSequenceElement()) { 5874 composePositiveInt(t, "SubDetailComponent", "sequence", element.getSequenceElement(), -1); 5875 } 5876 for (int i = 0; i < element.getTraceNumber().size(); i++) { 5877 composeIdentifier(t, "SubDetailComponent", "traceNumber", element.getTraceNumber().get(i), i); 5878 } 5879 if (element.hasRevenue()) { 5880 composeCodeableConcept(t, "SubDetailComponent", "revenue", element.getRevenue(), -1); 5881 } 5882 if (element.hasCategory()) { 5883 composeCodeableConcept(t, "SubDetailComponent", "category", element.getCategory(), -1); 5884 } 5885 if (element.hasProductOrService()) { 5886 composeCodeableConcept(t, "SubDetailComponent", "productOrService", element.getProductOrService(), -1); 5887 } 5888 if (element.hasProductOrServiceEnd()) { 5889 composeCodeableConcept(t, "SubDetailComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1); 5890 } 5891 for (int i = 0; i < element.getModifier().size(); i++) { 5892 composeCodeableConcept(t, "SubDetailComponent", "modifier", element.getModifier().get(i), i); 5893 } 5894 for (int i = 0; i < element.getProgramCode().size(); i++) { 5895 composeCodeableConcept(t, "SubDetailComponent", "programCode", element.getProgramCode().get(i), i); 5896 } 5897 if (element.hasPatientPaid()) { 5898 composeMoney(t, "SubDetailComponent", "patientPaid", element.getPatientPaid(), -1); 5899 } 5900 if (element.hasQuantity()) { 5901 composeQuantity(t, "SubDetailComponent", "quantity", element.getQuantity(), -1); 5902 } 5903 if (element.hasUnitPrice()) { 5904 composeMoney(t, "SubDetailComponent", "unitPrice", element.getUnitPrice(), -1); 5905 } 5906 if (element.hasFactorElement()) { 5907 composeDecimal(t, "SubDetailComponent", "factor", element.getFactorElement(), -1); 5908 } 5909 if (element.hasTax()) { 5910 composeMoney(t, "SubDetailComponent", "tax", element.getTax(), -1); 5911 } 5912 if (element.hasNet()) { 5913 composeMoney(t, "SubDetailComponent", "net", element.getNet(), -1); 5914 } 5915 for (int i = 0; i < element.getUdi().size(); i++) { 5916 composeReference(t, "SubDetailComponent", "udi", element.getUdi().get(i), i); 5917 } 5918 } 5919 5920 protected void composeClaimResponse(Complex parent, String parentType, String name, ClaimResponse element, int index) { 5921 if (element == null) 5922 return; 5923 Complex t; 5924 if (Utilities.noString(parentType)) 5925 t = parent; 5926 else { 5927 t = parent.predicate("fhir:"+name,index > -1); 5928 } 5929 composeDomainResource(t, "ClaimResponse", name, element, index); 5930 for (int i = 0; i < element.getIdentifier().size(); i++) { 5931 composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier().get(i), i); 5932 } 5933 for (int i = 0; i < element.getTraceNumber().size(); i++) { 5934 composeIdentifier(t, "ClaimResponse", "traceNumber", element.getTraceNumber().get(i), i); 5935 } 5936 if (element.hasStatusElement()) { 5937 composeEnum(t, "ClaimResponse", "status", element.getStatusElement(), -1); 5938 } 5939 if (element.hasType()) { 5940 composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1); 5941 } 5942 if (element.hasSubType()) { 5943 composeCodeableConcept(t, "ClaimResponse", "subType", element.getSubType(), -1); 5944 } 5945 if (element.hasUseElement()) { 5946 composeEnum(t, "ClaimResponse", "use", element.getUseElement(), -1); 5947 } 5948 if (element.hasPatient()) { 5949 composeReference(t, "ClaimResponse", "patient", element.getPatient(), -1); 5950 } 5951 if (element.hasCreatedElement()) { 5952 composeDateTime(t, "ClaimResponse", "created", element.getCreatedElement(), -1); 5953 } 5954 if (element.hasInsurer()) { 5955 composeReference(t, "ClaimResponse", "insurer", element.getInsurer(), -1); 5956 } 5957 if (element.hasRequestor()) { 5958 composeReference(t, "ClaimResponse", "requestor", element.getRequestor(), -1); 5959 } 5960 if (element.hasRequest()) { 5961 composeReference(t, "ClaimResponse", "request", element.getRequest(), -1); 5962 } 5963 if (element.hasOutcomeElement()) { 5964 composeEnum(t, "ClaimResponse", "outcome", element.getOutcomeElement(), -1); 5965 } 5966 if (element.hasDecision()) { 5967 composeCodeableConcept(t, "ClaimResponse", "decision", element.getDecision(), -1); 5968 } 5969 if (element.hasDispositionElement()) { 5970 composeString(t, "ClaimResponse", "disposition", element.getDispositionElement(), -1); 5971 } 5972 if (element.hasPreAuthRefElement()) { 5973 composeString(t, "ClaimResponse", "preAuthRef", element.getPreAuthRefElement(), -1); 5974 } 5975 if (element.hasPreAuthPeriod()) { 5976 composePeriod(t, "ClaimResponse", "preAuthPeriod", element.getPreAuthPeriod(), -1); 5977 } 5978 for (int i = 0; i < element.getEvent().size(); i++) { 5979 composeClaimResponseEventComponent(t, "ClaimResponse", "event", element.getEvent().get(i), i); 5980 } 5981 if (element.hasPayeeType()) { 5982 composeCodeableConcept(t, "ClaimResponse", "payeeType", element.getPayeeType(), -1); 5983 } 5984 for (int i = 0; i < element.getEncounter().size(); i++) { 5985 composeReference(t, "ClaimResponse", "encounter", element.getEncounter().get(i), i); 5986 } 5987 if (element.hasDiagnosisRelatedGroup()) { 5988 composeCodeableConcept(t, "ClaimResponse", "diagnosisRelatedGroup", element.getDiagnosisRelatedGroup(), -1); 5989 } 5990 for (int i = 0; i < element.getItem().size(); i++) { 5991 composeClaimResponseItemComponent(t, "ClaimResponse", "item", element.getItem().get(i), i); 5992 } 5993 for (int i = 0; i < element.getAddItem().size(); i++) { 5994 composeClaimResponseAddedItemComponent(t, "ClaimResponse", "addItem", element.getAddItem().get(i), i); 5995 } 5996 for (int i = 0; i < element.getAdjudication().size(); i++) { 5997 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 5998 } 5999 for (int i = 0; i < element.getTotal().size(); i++) { 6000 composeClaimResponseTotalComponent(t, "ClaimResponse", "total", element.getTotal().get(i), i); 6001 } 6002 if (element.hasPayment()) { 6003 composeClaimResponsePaymentComponent(t, "ClaimResponse", "payment", element.getPayment(), -1); 6004 } 6005 if (element.hasFundsReserve()) { 6006 composeCodeableConcept(t, "ClaimResponse", "fundsReserve", element.getFundsReserve(), -1); 6007 } 6008 if (element.hasFormCode()) { 6009 composeCodeableConcept(t, "ClaimResponse", "formCode", element.getFormCode(), -1); 6010 } 6011 if (element.hasForm()) { 6012 composeAttachment(t, "ClaimResponse", "form", element.getForm(), -1); 6013 } 6014 for (int i = 0; i < element.getProcessNote().size(); i++) { 6015 composeClaimResponseNoteComponent(t, "ClaimResponse", "processNote", element.getProcessNote().get(i), i); 6016 } 6017 for (int i = 0; i < element.getCommunicationRequest().size(); i++) { 6018 composeReference(t, "ClaimResponse", "communicationRequest", element.getCommunicationRequest().get(i), i); 6019 } 6020 for (int i = 0; i < element.getInsurance().size(); i++) { 6021 composeClaimResponseInsuranceComponent(t, "ClaimResponse", "insurance", element.getInsurance().get(i), i); 6022 } 6023 for (int i = 0; i < element.getError().size(); i++) { 6024 composeClaimResponseErrorComponent(t, "ClaimResponse", "error", element.getError().get(i), i); 6025 } 6026 } 6027 6028 protected void composeClaimResponseEventComponent(Complex parent, String parentType, String name, ClaimResponse.ClaimResponseEventComponent element, int index) { 6029 if (element == null) 6030 return; 6031 Complex t; 6032 if (Utilities.noString(parentType)) 6033 t = parent; 6034 else { 6035 t = parent.predicate("fhir:"+name,index > -1); 6036 } 6037 composeBackboneElement(t, "event", name, element, index); 6038 if (element.hasType()) { 6039 composeCodeableConcept(t, "ClaimResponseEventComponent", "type", element.getType(), -1); 6040 } 6041 if (element.hasWhen()) { 6042 composeType(t, "ClaimResponseEventComponent", "when", element.getWhen(), -1); 6043 } 6044 } 6045 6046 protected void composeClaimResponseItemComponent(Complex parent, String parentType, String name, ClaimResponse.ItemComponent element, int index) { 6047 if (element == null) 6048 return; 6049 Complex t; 6050 if (Utilities.noString(parentType)) 6051 t = parent; 6052 else { 6053 t = parent.predicate("fhir:"+name,index > -1); 6054 } 6055 composeBackboneElement(t, "item", name, element, index); 6056 if (element.hasItemSequenceElement()) { 6057 composePositiveInt(t, "ItemComponent", "itemSequence", element.getItemSequenceElement(), -1); 6058 } 6059 for (int i = 0; i < element.getTraceNumber().size(); i++) { 6060 composeIdentifier(t, "ItemComponent", "traceNumber", element.getTraceNumber().get(i), i); 6061 } 6062 for (int i = 0; i < element.getNoteNumber().size(); i++) { 6063 composePositiveInt(t, "ItemComponent", "noteNumber", element.getNoteNumber().get(i), i); 6064 } 6065 if (element.hasReviewOutcome()) { 6066 composeClaimResponseReviewOutcomeComponent(t, "ItemComponent", "reviewOutcome", element.getReviewOutcome(), -1); 6067 } 6068 for (int i = 0; i < element.getAdjudication().size(); i++) { 6069 composeClaimResponseAdjudicationComponent(t, "ItemComponent", "adjudication", element.getAdjudication().get(i), i); 6070 } 6071 for (int i = 0; i < element.getDetail().size(); i++) { 6072 composeClaimResponseItemDetailComponent(t, "ItemComponent", "detail", element.getDetail().get(i), i); 6073 } 6074 } 6075 6076 protected void composeClaimResponseReviewOutcomeComponent(Complex parent, String parentType, String name, ClaimResponse.ReviewOutcomeComponent element, int index) { 6077 if (element == null) 6078 return; 6079 Complex t; 6080 if (Utilities.noString(parentType)) 6081 t = parent; 6082 else { 6083 t = parent.predicate("fhir:"+name,index > -1); 6084 } 6085 composeBackboneElement(t, "reviewOutcome", name, element, index); 6086 if (element.hasDecision()) { 6087 composeCodeableConcept(t, "ReviewOutcomeComponent", "decision", element.getDecision(), -1); 6088 } 6089 for (int i = 0; i < element.getReason().size(); i++) { 6090 composeCodeableConcept(t, "ReviewOutcomeComponent", "reason", element.getReason().get(i), i); 6091 } 6092 if (element.hasPreAuthRefElement()) { 6093 composeString(t, "ReviewOutcomeComponent", "preAuthRef", element.getPreAuthRefElement(), -1); 6094 } 6095 if (element.hasPreAuthPeriod()) { 6096 composePeriod(t, "ReviewOutcomeComponent", "preAuthPeriod", element.getPreAuthPeriod(), -1); 6097 } 6098 } 6099 6100 protected void composeClaimResponseAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.AdjudicationComponent element, int index) { 6101 if (element == null) 6102 return; 6103 Complex t; 6104 if (Utilities.noString(parentType)) 6105 t = parent; 6106 else { 6107 t = parent.predicate("fhir:"+name,index > -1); 6108 } 6109 composeBackboneElement(t, "adjudication", name, element, index); 6110 if (element.hasCategory()) { 6111 composeCodeableConcept(t, "AdjudicationComponent", "category", element.getCategory(), -1); 6112 } 6113 if (element.hasReason()) { 6114 composeCodeableConcept(t, "AdjudicationComponent", "reason", element.getReason(), -1); 6115 } 6116 if (element.hasAmount()) { 6117 composeMoney(t, "AdjudicationComponent", "amount", element.getAmount(), -1); 6118 } 6119 if (element.hasQuantity()) { 6120 composeQuantity(t, "AdjudicationComponent", "quantity", element.getQuantity(), -1); 6121 } 6122 } 6123 6124 protected void composeClaimResponseItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.ItemDetailComponent element, int index) { 6125 if (element == null) 6126 return; 6127 Complex t; 6128 if (Utilities.noString(parentType)) 6129 t = parent; 6130 else { 6131 t = parent.predicate("fhir:"+name,index > -1); 6132 } 6133 composeBackboneElement(t, "detail", name, element, index); 6134 if (element.hasDetailSequenceElement()) { 6135 composePositiveInt(t, "ItemDetailComponent", "detailSequence", element.getDetailSequenceElement(), -1); 6136 } 6137 for (int i = 0; i < element.getTraceNumber().size(); i++) { 6138 composeIdentifier(t, "ItemDetailComponent", "traceNumber", element.getTraceNumber().get(i), i); 6139 } 6140 for (int i = 0; i < element.getNoteNumber().size(); i++) { 6141 composePositiveInt(t, "ItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i); 6142 } 6143 if (element.hasReviewOutcome()) { 6144 composeClaimResponseReviewOutcomeComponent(t, "ItemDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1); 6145 } 6146 for (int i = 0; i < element.getAdjudication().size(); i++) { 6147 composeClaimResponseAdjudicationComponent(t, "ItemDetailComponent", "adjudication", element.getAdjudication().get(i), i); 6148 } 6149 for (int i = 0; i < element.getSubDetail().size(); i++) { 6150 composeClaimResponseSubDetailComponent(t, "ItemDetailComponent", "subDetail", element.getSubDetail().get(i), i); 6151 } 6152 } 6153 6154 protected void composeClaimResponseSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.SubDetailComponent element, int index) { 6155 if (element == null) 6156 return; 6157 Complex t; 6158 if (Utilities.noString(parentType)) 6159 t = parent; 6160 else { 6161 t = parent.predicate("fhir:"+name,index > -1); 6162 } 6163 composeBackboneElement(t, "subDetail", name, element, index); 6164 if (element.hasSubDetailSequenceElement()) { 6165 composePositiveInt(t, "SubDetailComponent", "subDetailSequence", element.getSubDetailSequenceElement(), -1); 6166 } 6167 for (int i = 0; i < element.getTraceNumber().size(); i++) { 6168 composeIdentifier(t, "SubDetailComponent", "traceNumber", element.getTraceNumber().get(i), i); 6169 } 6170 for (int i = 0; i < element.getNoteNumber().size(); i++) { 6171 composePositiveInt(t, "SubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i); 6172 } 6173 if (element.hasReviewOutcome()) { 6174 composeClaimResponseReviewOutcomeComponent(t, "SubDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1); 6175 } 6176 for (int i = 0; i < element.getAdjudication().size(); i++) { 6177 composeClaimResponseAdjudicationComponent(t, "SubDetailComponent", "adjudication", element.getAdjudication().get(i), i); 6178 } 6179 } 6180 6181 protected void composeClaimResponseAddedItemComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemComponent element, int index) { 6182 if (element == null) 6183 return; 6184 Complex t; 6185 if (Utilities.noString(parentType)) 6186 t = parent; 6187 else { 6188 t = parent.predicate("fhir:"+name,index > -1); 6189 } 6190 composeBackboneElement(t, "addItem", name, element, index); 6191 for (int i = 0; i < element.getItemSequence().size(); i++) { 6192 composePositiveInt(t, "AddedItemComponent", "itemSequence", element.getItemSequence().get(i), i); 6193 } 6194 for (int i = 0; i < element.getDetailSequence().size(); i++) { 6195 composePositiveInt(t, "AddedItemComponent", "detailSequence", element.getDetailSequence().get(i), i); 6196 } 6197 for (int i = 0; i < element.getSubdetailSequence().size(); i++) { 6198 composePositiveInt(t, "AddedItemComponent", "subdetailSequence", element.getSubdetailSequence().get(i), i); 6199 } 6200 for (int i = 0; i < element.getTraceNumber().size(); i++) { 6201 composeIdentifier(t, "AddedItemComponent", "traceNumber", element.getTraceNumber().get(i), i); 6202 } 6203 for (int i = 0; i < element.getProvider().size(); i++) { 6204 composeReference(t, "AddedItemComponent", "provider", element.getProvider().get(i), i); 6205 } 6206 if (element.hasRevenue()) { 6207 composeCodeableConcept(t, "AddedItemComponent", "revenue", element.getRevenue(), -1); 6208 } 6209 if (element.hasProductOrService()) { 6210 composeCodeableConcept(t, "AddedItemComponent", "productOrService", element.getProductOrService(), -1); 6211 } 6212 if (element.hasProductOrServiceEnd()) { 6213 composeCodeableConcept(t, "AddedItemComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1); 6214 } 6215 for (int i = 0; i < element.getRequest().size(); i++) { 6216 composeReference(t, "AddedItemComponent", "request", element.getRequest().get(i), i); 6217 } 6218 for (int i = 0; i < element.getModifier().size(); i++) { 6219 composeCodeableConcept(t, "AddedItemComponent", "modifier", element.getModifier().get(i), i); 6220 } 6221 for (int i = 0; i < element.getProgramCode().size(); i++) { 6222 composeCodeableConcept(t, "AddedItemComponent", "programCode", element.getProgramCode().get(i), i); 6223 } 6224 if (element.hasServiced()) { 6225 composeType(t, "AddedItemComponent", "serviced", element.getServiced(), -1); 6226 } 6227 if (element.hasLocation()) { 6228 composeType(t, "AddedItemComponent", "location", element.getLocation(), -1); 6229 } 6230 if (element.hasQuantity()) { 6231 composeQuantity(t, "AddedItemComponent", "quantity", element.getQuantity(), -1); 6232 } 6233 if (element.hasUnitPrice()) { 6234 composeMoney(t, "AddedItemComponent", "unitPrice", element.getUnitPrice(), -1); 6235 } 6236 if (element.hasFactorElement()) { 6237 composeDecimal(t, "AddedItemComponent", "factor", element.getFactorElement(), -1); 6238 } 6239 if (element.hasTax()) { 6240 composeMoney(t, "AddedItemComponent", "tax", element.getTax(), -1); 6241 } 6242 if (element.hasNet()) { 6243 composeMoney(t, "AddedItemComponent", "net", element.getNet(), -1); 6244 } 6245 for (int i = 0; i < element.getBodySite().size(); i++) { 6246 composeClaimResponseBodySiteComponent(t, "AddedItemComponent", "bodySite", element.getBodySite().get(i), i); 6247 } 6248 for (int i = 0; i < element.getNoteNumber().size(); i++) { 6249 composePositiveInt(t, "AddedItemComponent", "noteNumber", element.getNoteNumber().get(i), i); 6250 } 6251 if (element.hasReviewOutcome()) { 6252 composeClaimResponseReviewOutcomeComponent(t, "AddedItemComponent", "reviewOutcome", element.getReviewOutcome(), -1); 6253 } 6254 for (int i = 0; i < element.getAdjudication().size(); i++) { 6255 composeClaimResponseAdjudicationComponent(t, "AddedItemComponent", "adjudication", element.getAdjudication().get(i), i); 6256 } 6257 for (int i = 0; i < element.getDetail().size(); i++) { 6258 composeClaimResponseAddedItemDetailComponent(t, "AddedItemComponent", "detail", element.getDetail().get(i), i); 6259 } 6260 } 6261 6262 protected void composeClaimResponseBodySiteComponent(Complex parent, String parentType, String name, ClaimResponse.BodySiteComponent element, int index) { 6263 if (element == null) 6264 return; 6265 Complex t; 6266 if (Utilities.noString(parentType)) 6267 t = parent; 6268 else { 6269 t = parent.predicate("fhir:"+name,index > -1); 6270 } 6271 composeBackboneElement(t, "bodySite", name, element, index); 6272 for (int i = 0; i < element.getSite().size(); i++) { 6273 composeCodeableReference(t, "BodySiteComponent", "site", element.getSite().get(i), i); 6274 } 6275 for (int i = 0; i < element.getSubSite().size(); i++) { 6276 composeCodeableConcept(t, "BodySiteComponent", "subSite", element.getSubSite().get(i), i); 6277 } 6278 } 6279 6280 protected void composeClaimResponseAddedItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemDetailComponent element, int index) { 6281 if (element == null) 6282 return; 6283 Complex t; 6284 if (Utilities.noString(parentType)) 6285 t = parent; 6286 else { 6287 t = parent.predicate("fhir:"+name,index > -1); 6288 } 6289 composeBackboneElement(t, "detail", name, element, index); 6290 for (int i = 0; i < element.getTraceNumber().size(); i++) { 6291 composeIdentifier(t, "AddedItemDetailComponent", "traceNumber", element.getTraceNumber().get(i), i); 6292 } 6293 if (element.hasRevenue()) { 6294 composeCodeableConcept(t, "AddedItemDetailComponent", "revenue", element.getRevenue(), -1); 6295 } 6296 if (element.hasProductOrService()) { 6297 composeCodeableConcept(t, "AddedItemDetailComponent", "productOrService", element.getProductOrService(), -1); 6298 } 6299 if (element.hasProductOrServiceEnd()) { 6300 composeCodeableConcept(t, "AddedItemDetailComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1); 6301 } 6302 for (int i = 0; i < element.getModifier().size(); i++) { 6303 composeCodeableConcept(t, "AddedItemDetailComponent", "modifier", element.getModifier().get(i), i); 6304 } 6305 if (element.hasQuantity()) { 6306 composeQuantity(t, "AddedItemDetailComponent", "quantity", element.getQuantity(), -1); 6307 } 6308 if (element.hasUnitPrice()) { 6309 composeMoney(t, "AddedItemDetailComponent", "unitPrice", element.getUnitPrice(), -1); 6310 } 6311 if (element.hasFactorElement()) { 6312 composeDecimal(t, "AddedItemDetailComponent", "factor", element.getFactorElement(), -1); 6313 } 6314 if (element.hasTax()) { 6315 composeMoney(t, "AddedItemDetailComponent", "tax", element.getTax(), -1); 6316 } 6317 if (element.hasNet()) { 6318 composeMoney(t, "AddedItemDetailComponent", "net", element.getNet(), -1); 6319 } 6320 for (int i = 0; i < element.getNoteNumber().size(); i++) { 6321 composePositiveInt(t, "AddedItemDetailComponent", "noteNumber", element.getNoteNumber().get(i), i); 6322 } 6323 if (element.hasReviewOutcome()) { 6324 composeClaimResponseReviewOutcomeComponent(t, "AddedItemDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1); 6325 } 6326 for (int i = 0; i < element.getAdjudication().size(); i++) { 6327 composeClaimResponseAdjudicationComponent(t, "AddedItemDetailComponent", "adjudication", element.getAdjudication().get(i), i); 6328 } 6329 for (int i = 0; i < element.getSubDetail().size(); i++) { 6330 composeClaimResponseAddedItemSubDetailComponent(t, "AddedItemDetailComponent", "subDetail", element.getSubDetail().get(i), i); 6331 } 6332 } 6333 6334 protected void composeClaimResponseAddedItemSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemSubDetailComponent element, int index) { 6335 if (element == null) 6336 return; 6337 Complex t; 6338 if (Utilities.noString(parentType)) 6339 t = parent; 6340 else { 6341 t = parent.predicate("fhir:"+name,index > -1); 6342 } 6343 composeBackboneElement(t, "subDetail", name, element, index); 6344 for (int i = 0; i < element.getTraceNumber().size(); i++) { 6345 composeIdentifier(t, "AddedItemSubDetailComponent", "traceNumber", element.getTraceNumber().get(i), i); 6346 } 6347 if (element.hasRevenue()) { 6348 composeCodeableConcept(t, "AddedItemSubDetailComponent", "revenue", element.getRevenue(), -1); 6349 } 6350 if (element.hasProductOrService()) { 6351 composeCodeableConcept(t, "AddedItemSubDetailComponent", "productOrService", element.getProductOrService(), -1); 6352 } 6353 if (element.hasProductOrServiceEnd()) { 6354 composeCodeableConcept(t, "AddedItemSubDetailComponent", "productOrServiceEnd", element.getProductOrServiceEnd(), -1); 6355 } 6356 for (int i = 0; i < element.getModifier().size(); i++) { 6357 composeCodeableConcept(t, "AddedItemSubDetailComponent", "modifier", element.getModifier().get(i), i); 6358 } 6359 if (element.hasQuantity()) { 6360 composeQuantity(t, "AddedItemSubDetailComponent", "quantity", element.getQuantity(), -1); 6361 } 6362 if (element.hasUnitPrice()) { 6363 composeMoney(t, "AddedItemSubDetailComponent", "unitPrice", element.getUnitPrice(), -1); 6364 } 6365 if (element.hasFactorElement()) { 6366 composeDecimal(t, "AddedItemSubDetailComponent", "factor", element.getFactorElement(), -1); 6367 } 6368 if (element.hasTax()) { 6369 composeMoney(t, "AddedItemSubDetailComponent", "tax", element.getTax(), -1); 6370 } 6371 if (element.hasNet()) { 6372 composeMoney(t, "AddedItemSubDetailComponent", "net", element.getNet(), -1); 6373 } 6374 for (int i = 0; i < element.getNoteNumber().size(); i++) { 6375 composePositiveInt(t, "AddedItemSubDetailComponent", "noteNumber", element.getNoteNumber().get(i), i); 6376 } 6377 if (element.hasReviewOutcome()) { 6378 composeClaimResponseReviewOutcomeComponent(t, "AddedItemSubDetailComponent", "reviewOutcome", element.getReviewOutcome(), -1); 6379 } 6380 for (int i = 0; i < element.getAdjudication().size(); i++) { 6381 composeClaimResponseAdjudicationComponent(t, "AddedItemSubDetailComponent", "adjudication", element.getAdjudication().get(i), i); 6382 } 6383 } 6384 6385 protected void composeClaimResponseTotalComponent(Complex parent, String parentType, String name, ClaimResponse.TotalComponent element, int index) { 6386 if (element == null) 6387 return; 6388 Complex t; 6389 if (Utilities.noString(parentType)) 6390 t = parent; 6391 else { 6392 t = parent.predicate("fhir:"+name,index > -1); 6393 } 6394 composeBackboneElement(t, "total", name, element, index); 6395 if (element.hasCategory()) { 6396 composeCodeableConcept(t, "TotalComponent", "category", element.getCategory(), -1); 6397 } 6398 if (element.hasAmount()) { 6399 composeMoney(t, "TotalComponent", "amount", element.getAmount(), -1); 6400 } 6401 } 6402 6403 protected void composeClaimResponsePaymentComponent(Complex parent, String parentType, String name, ClaimResponse.PaymentComponent element, int index) { 6404 if (element == null) 6405 return; 6406 Complex t; 6407 if (Utilities.noString(parentType)) 6408 t = parent; 6409 else { 6410 t = parent.predicate("fhir:"+name,index > -1); 6411 } 6412 composeBackboneElement(t, "payment", name, element, index); 6413 if (element.hasType()) { 6414 composeCodeableConcept(t, "PaymentComponent", "type", element.getType(), -1); 6415 } 6416 if (element.hasAdjustment()) { 6417 composeMoney(t, "PaymentComponent", "adjustment", element.getAdjustment(), -1); 6418 } 6419 if (element.hasAdjustmentReason()) { 6420 composeCodeableConcept(t, "PaymentComponent", "adjustmentReason", element.getAdjustmentReason(), -1); 6421 } 6422 if (element.hasDateElement()) { 6423 composeDate(t, "PaymentComponent", "date", element.getDateElement(), -1); 6424 } 6425 if (element.hasAmount()) { 6426 composeMoney(t, "PaymentComponent", "amount", element.getAmount(), -1); 6427 } 6428 if (element.hasIdentifier()) { 6429 composeIdentifier(t, "PaymentComponent", "identifier", element.getIdentifier(), -1); 6430 } 6431 } 6432 6433 protected void composeClaimResponseNoteComponent(Complex parent, String parentType, String name, ClaimResponse.NoteComponent element, int index) { 6434 if (element == null) 6435 return; 6436 Complex t; 6437 if (Utilities.noString(parentType)) 6438 t = parent; 6439 else { 6440 t = parent.predicate("fhir:"+name,index > -1); 6441 } 6442 composeBackboneElement(t, "processNote", name, element, index); 6443 if (element.hasNumberElement()) { 6444 composePositiveInt(t, "NoteComponent", "number", element.getNumberElement(), -1); 6445 } 6446 if (element.hasType()) { 6447 composeCodeableConcept(t, "NoteComponent", "type", element.getType(), -1); 6448 } 6449 if (element.hasTextElement()) { 6450 composeString(t, "NoteComponent", "text", element.getTextElement(), -1); 6451 } 6452 if (element.hasLanguage()) { 6453 composeCodeableConcept(t, "NoteComponent", "language", element.getLanguage(), -1); 6454 } 6455 } 6456 6457 protected void composeClaimResponseInsuranceComponent(Complex parent, String parentType, String name, ClaimResponse.InsuranceComponent element, int index) { 6458 if (element == null) 6459 return; 6460 Complex t; 6461 if (Utilities.noString(parentType)) 6462 t = parent; 6463 else { 6464 t = parent.predicate("fhir:"+name,index > -1); 6465 } 6466 composeBackboneElement(t, "insurance", name, element, index); 6467 if (element.hasSequenceElement()) { 6468 composePositiveInt(t, "InsuranceComponent", "sequence", element.getSequenceElement(), -1); 6469 } 6470 if (element.hasFocalElement()) { 6471 composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1); 6472 } 6473 if (element.hasCoverage()) { 6474 composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1); 6475 } 6476 if (element.hasBusinessArrangementElement()) { 6477 composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1); 6478 } 6479 if (element.hasClaimResponse()) { 6480 composeReference(t, "InsuranceComponent", "claimResponse", element.getClaimResponse(), -1); 6481 } 6482 } 6483 6484 protected void composeClaimResponseErrorComponent(Complex parent, String parentType, String name, ClaimResponse.ErrorComponent element, int index) { 6485 if (element == null) 6486 return; 6487 Complex t; 6488 if (Utilities.noString(parentType)) 6489 t = parent; 6490 else { 6491 t = parent.predicate("fhir:"+name,index > -1); 6492 } 6493 composeBackboneElement(t, "error", name, element, index); 6494 if (element.hasItemSequenceElement()) { 6495 composePositiveInt(t, "ErrorComponent", "itemSequence", element.getItemSequenceElement(), -1); 6496 } 6497 if (element.hasDetailSequenceElement()) { 6498 composePositiveInt(t, "ErrorComponent", "detailSequence", element.getDetailSequenceElement(), -1); 6499 } 6500 if (element.hasSubDetailSequenceElement()) { 6501 composePositiveInt(t, "ErrorComponent", "subDetailSequence", element.getSubDetailSequenceElement(), -1); 6502 } 6503 if (element.hasCode()) { 6504 composeCodeableConcept(t, "ErrorComponent", "code", element.getCode(), -1); 6505 } 6506 for (int i = 0; i < element.getExpression().size(); i++) { 6507 composeString(t, "ErrorComponent", "expression", element.getExpression().get(i), i); 6508 } 6509 } 6510 6511 protected void composeClinicalImpression(Complex parent, String parentType, String name, ClinicalImpression element, int index) { 6512 if (element == null) 6513 return; 6514 Complex t; 6515 if (Utilities.noString(parentType)) 6516 t = parent; 6517 else { 6518 t = parent.predicate("fhir:"+name,index > -1); 6519 } 6520 composeDomainResource(t, "ClinicalImpression", name, element, index); 6521 for (int i = 0; i < element.getIdentifier().size(); i++) { 6522 composeIdentifier(t, "ClinicalImpression", "identifier", element.getIdentifier().get(i), i); 6523 } 6524 if (element.hasStatusElement()) { 6525 composeEnum(t, "ClinicalImpression", "status", element.getStatusElement(), -1); 6526 } 6527 if (element.hasStatusReason()) { 6528 composeCodeableConcept(t, "ClinicalImpression", "statusReason", element.getStatusReason(), -1); 6529 } 6530 if (element.hasDescriptionElement()) { 6531 composeString(t, "ClinicalImpression", "description", element.getDescriptionElement(), -1); 6532 } 6533 if (element.hasSubject()) { 6534 composeReference(t, "ClinicalImpression", "subject", element.getSubject(), -1); 6535 } 6536 if (element.hasEncounter()) { 6537 composeReference(t, "ClinicalImpression", "encounter", element.getEncounter(), -1); 6538 } 6539 if (element.hasEffective()) { 6540 composeType(t, "ClinicalImpression", "effective", element.getEffective(), -1); 6541 } 6542 if (element.hasDateElement()) { 6543 composeDateTime(t, "ClinicalImpression", "date", element.getDateElement(), -1); 6544 } 6545 if (element.hasPerformer()) { 6546 composeReference(t, "ClinicalImpression", "performer", element.getPerformer(), -1); 6547 } 6548 if (element.hasPrevious()) { 6549 composeReference(t, "ClinicalImpression", "previous", element.getPrevious(), -1); 6550 } 6551 for (int i = 0; i < element.getProblem().size(); i++) { 6552 composeReference(t, "ClinicalImpression", "problem", element.getProblem().get(i), i); 6553 } 6554 if (element.hasChangePattern()) { 6555 composeCodeableConcept(t, "ClinicalImpression", "changePattern", element.getChangePattern(), -1); 6556 } 6557 for (int i = 0; i < element.getProtocol().size(); i++) { 6558 composeUri(t, "ClinicalImpression", "protocol", element.getProtocol().get(i), i); 6559 } 6560 if (element.hasSummaryElement()) { 6561 composeString(t, "ClinicalImpression", "summary", element.getSummaryElement(), -1); 6562 } 6563 for (int i = 0; i < element.getFinding().size(); i++) { 6564 composeClinicalImpressionFindingComponent(t, "ClinicalImpression", "finding", element.getFinding().get(i), i); 6565 } 6566 for (int i = 0; i < element.getPrognosisCodeableConcept().size(); i++) { 6567 composeCodeableConcept(t, "ClinicalImpression", "prognosisCodeableConcept", element.getPrognosisCodeableConcept().get(i), i); 6568 } 6569 for (int i = 0; i < element.getPrognosisReference().size(); i++) { 6570 composeReference(t, "ClinicalImpression", "prognosisReference", element.getPrognosisReference().get(i), i); 6571 } 6572 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 6573 composeReference(t, "ClinicalImpression", "supportingInfo", element.getSupportingInfo().get(i), i); 6574 } 6575 for (int i = 0; i < element.getNote().size(); i++) { 6576 composeAnnotation(t, "ClinicalImpression", "note", element.getNote().get(i), i); 6577 } 6578 } 6579 6580 protected void composeClinicalImpressionFindingComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionFindingComponent element, int index) { 6581 if (element == null) 6582 return; 6583 Complex t; 6584 if (Utilities.noString(parentType)) 6585 t = parent; 6586 else { 6587 t = parent.predicate("fhir:"+name,index > -1); 6588 } 6589 composeBackboneElement(t, "finding", name, element, index); 6590 if (element.hasItem()) { 6591 composeCodeableReference(t, "ClinicalImpressionFindingComponent", "item", element.getItem(), -1); 6592 } 6593 if (element.hasBasisElement()) { 6594 composeString(t, "ClinicalImpressionFindingComponent", "basis", element.getBasisElement(), -1); 6595 } 6596 } 6597 6598 protected void composeClinicalUseDefinition(Complex parent, String parentType, String name, ClinicalUseDefinition element, int index) { 6599 if (element == null) 6600 return; 6601 Complex t; 6602 if (Utilities.noString(parentType)) 6603 t = parent; 6604 else { 6605 t = parent.predicate("fhir:"+name,index > -1); 6606 } 6607 composeDomainResource(t, "ClinicalUseDefinition", name, element, index); 6608 for (int i = 0; i < element.getIdentifier().size(); i++) { 6609 composeIdentifier(t, "ClinicalUseDefinition", "identifier", element.getIdentifier().get(i), i); 6610 } 6611 if (element.hasTypeElement()) { 6612 composeEnum(t, "ClinicalUseDefinition", "type", element.getTypeElement(), -1); 6613 } 6614 for (int i = 0; i < element.getCategory().size(); i++) { 6615 composeCodeableConcept(t, "ClinicalUseDefinition", "category", element.getCategory().get(i), i); 6616 } 6617 for (int i = 0; i < element.getSubject().size(); i++) { 6618 composeReference(t, "ClinicalUseDefinition", "subject", element.getSubject().get(i), i); 6619 } 6620 if (element.hasStatus()) { 6621 composeCodeableConcept(t, "ClinicalUseDefinition", "status", element.getStatus(), -1); 6622 } 6623 if (element.hasContraindication()) { 6624 composeClinicalUseDefinitionContraindicationComponent(t, "ClinicalUseDefinition", "contraindication", element.getContraindication(), -1); 6625 } 6626 if (element.hasIndication()) { 6627 composeClinicalUseDefinitionIndicationComponent(t, "ClinicalUseDefinition", "indication", element.getIndication(), -1); 6628 } 6629 if (element.hasInteraction()) { 6630 composeClinicalUseDefinitionInteractionComponent(t, "ClinicalUseDefinition", "interaction", element.getInteraction(), -1); 6631 } 6632 for (int i = 0; i < element.getPopulation().size(); i++) { 6633 composeReference(t, "ClinicalUseDefinition", "population", element.getPopulation().get(i), i); 6634 } 6635 for (int i = 0; i < element.getLibrary().size(); i++) { 6636 composeCanonical(t, "ClinicalUseDefinition", "library", element.getLibrary().get(i), i); 6637 } 6638 if (element.hasUndesirableEffect()) { 6639 composeClinicalUseDefinitionUndesirableEffectComponent(t, "ClinicalUseDefinition", "undesirableEffect", element.getUndesirableEffect(), -1); 6640 } 6641 if (element.hasWarning()) { 6642 composeClinicalUseDefinitionWarningComponent(t, "ClinicalUseDefinition", "warning", element.getWarning(), -1); 6643 } 6644 } 6645 6646 protected void composeClinicalUseDefinitionContraindicationComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionContraindicationComponent element, int index) { 6647 if (element == null) 6648 return; 6649 Complex t; 6650 if (Utilities.noString(parentType)) 6651 t = parent; 6652 else { 6653 t = parent.predicate("fhir:"+name,index > -1); 6654 } 6655 composeBackboneElement(t, "contraindication", name, element, index); 6656 if (element.hasDiseaseSymptomProcedure()) { 6657 composeCodeableReference(t, "ClinicalUseDefinitionContraindicationComponent", "diseaseSymptomProcedure", element.getDiseaseSymptomProcedure(), -1); 6658 } 6659 if (element.hasDiseaseStatus()) { 6660 composeCodeableReference(t, "ClinicalUseDefinitionContraindicationComponent", "diseaseStatus", element.getDiseaseStatus(), -1); 6661 } 6662 for (int i = 0; i < element.getComorbidity().size(); i++) { 6663 composeCodeableReference(t, "ClinicalUseDefinitionContraindicationComponent", "comorbidity", element.getComorbidity().get(i), i); 6664 } 6665 for (int i = 0; i < element.getIndication().size(); i++) { 6666 composeReference(t, "ClinicalUseDefinitionContraindicationComponent", "indication", element.getIndication().get(i), i); 6667 } 6668 if (element.hasApplicability()) { 6669 composeExpression(t, "ClinicalUseDefinitionContraindicationComponent", "applicability", element.getApplicability(), -1); 6670 } 6671 for (int i = 0; i < element.getOtherTherapy().size(); i++) { 6672 composeClinicalUseDefinitionContraindicationOtherTherapyComponent(t, "ClinicalUseDefinitionContraindicationComponent", "otherTherapy", element.getOtherTherapy().get(i), i); 6673 } 6674 } 6675 6676 protected void composeClinicalUseDefinitionContraindicationOtherTherapyComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionContraindicationOtherTherapyComponent element, int index) { 6677 if (element == null) 6678 return; 6679 Complex t; 6680 if (Utilities.noString(parentType)) 6681 t = parent; 6682 else { 6683 t = parent.predicate("fhir:"+name,index > -1); 6684 } 6685 composeBackboneElement(t, "otherTherapy", name, element, index); 6686 if (element.hasRelationshipType()) { 6687 composeCodeableConcept(t, "ClinicalUseDefinitionContraindicationOtherTherapyComponent", "relationshipType", element.getRelationshipType(), -1); 6688 } 6689 if (element.hasTreatment()) { 6690 composeCodeableReference(t, "ClinicalUseDefinitionContraindicationOtherTherapyComponent", "treatment", element.getTreatment(), -1); 6691 } 6692 } 6693 6694 protected void composeClinicalUseDefinitionIndicationComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionIndicationComponent element, int index) { 6695 if (element == null) 6696 return; 6697 Complex t; 6698 if (Utilities.noString(parentType)) 6699 t = parent; 6700 else { 6701 t = parent.predicate("fhir:"+name,index > -1); 6702 } 6703 composeBackboneElement(t, "indication", name, element, index); 6704 if (element.hasDiseaseSymptomProcedure()) { 6705 composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "diseaseSymptomProcedure", element.getDiseaseSymptomProcedure(), -1); 6706 } 6707 if (element.hasDiseaseStatus()) { 6708 composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "diseaseStatus", element.getDiseaseStatus(), -1); 6709 } 6710 for (int i = 0; i < element.getComorbidity().size(); i++) { 6711 composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "comorbidity", element.getComorbidity().get(i), i); 6712 } 6713 if (element.hasIntendedEffect()) { 6714 composeCodeableReference(t, "ClinicalUseDefinitionIndicationComponent", "intendedEffect", element.getIntendedEffect(), -1); 6715 } 6716 if (element.hasDuration()) { 6717 composeType(t, "ClinicalUseDefinitionIndicationComponent", "duration", element.getDuration(), -1); 6718 } 6719 for (int i = 0; i < element.getUndesirableEffect().size(); i++) { 6720 composeReference(t, "ClinicalUseDefinitionIndicationComponent", "undesirableEffect", element.getUndesirableEffect().get(i), i); 6721 } 6722 if (element.hasApplicability()) { 6723 composeExpression(t, "ClinicalUseDefinitionIndicationComponent", "applicability", element.getApplicability(), -1); 6724 } 6725 for (int i = 0; i < element.getOtherTherapy().size(); i++) { 6726 composeClinicalUseDefinitionContraindicationOtherTherapyComponent(t, "ClinicalUseDefinitionIndicationComponent", "otherTherapy", element.getOtherTherapy().get(i), i); 6727 } 6728 } 6729 6730 protected void composeClinicalUseDefinitionInteractionComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionInteractionComponent element, int index) { 6731 if (element == null) 6732 return; 6733 Complex t; 6734 if (Utilities.noString(parentType)) 6735 t = parent; 6736 else { 6737 t = parent.predicate("fhir:"+name,index > -1); 6738 } 6739 composeBackboneElement(t, "interaction", name, element, index); 6740 for (int i = 0; i < element.getInteractant().size(); i++) { 6741 composeClinicalUseDefinitionInteractionInteractantComponent(t, "ClinicalUseDefinitionInteractionComponent", "interactant", element.getInteractant().get(i), i); 6742 } 6743 if (element.hasType()) { 6744 composeCodeableConcept(t, "ClinicalUseDefinitionInteractionComponent", "type", element.getType(), -1); 6745 } 6746 if (element.hasEffect()) { 6747 composeCodeableReference(t, "ClinicalUseDefinitionInteractionComponent", "effect", element.getEffect(), -1); 6748 } 6749 if (element.hasIncidence()) { 6750 composeCodeableConcept(t, "ClinicalUseDefinitionInteractionComponent", "incidence", element.getIncidence(), -1); 6751 } 6752 for (int i = 0; i < element.getManagement().size(); i++) { 6753 composeCodeableConcept(t, "ClinicalUseDefinitionInteractionComponent", "management", element.getManagement().get(i), i); 6754 } 6755 } 6756 6757 protected void composeClinicalUseDefinitionInteractionInteractantComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionInteractionInteractantComponent element, int index) { 6758 if (element == null) 6759 return; 6760 Complex t; 6761 if (Utilities.noString(parentType)) 6762 t = parent; 6763 else { 6764 t = parent.predicate("fhir:"+name,index > -1); 6765 } 6766 composeBackboneElement(t, "interactant", name, element, index); 6767 if (element.hasItem()) { 6768 composeType(t, "ClinicalUseDefinitionInteractionInteractantComponent", "item", element.getItem(), -1); 6769 } 6770 } 6771 6772 protected void composeClinicalUseDefinitionUndesirableEffectComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionUndesirableEffectComponent element, int index) { 6773 if (element == null) 6774 return; 6775 Complex t; 6776 if (Utilities.noString(parentType)) 6777 t = parent; 6778 else { 6779 t = parent.predicate("fhir:"+name,index > -1); 6780 } 6781 composeBackboneElement(t, "undesirableEffect", name, element, index); 6782 if (element.hasSymptomConditionEffect()) { 6783 composeCodeableReference(t, "ClinicalUseDefinitionUndesirableEffectComponent", "symptomConditionEffect", element.getSymptomConditionEffect(), -1); 6784 } 6785 if (element.hasClassification()) { 6786 composeCodeableConcept(t, "ClinicalUseDefinitionUndesirableEffectComponent", "classification", element.getClassification(), -1); 6787 } 6788 if (element.hasFrequencyOfOccurrence()) { 6789 composeCodeableConcept(t, "ClinicalUseDefinitionUndesirableEffectComponent", "frequencyOfOccurrence", element.getFrequencyOfOccurrence(), -1); 6790 } 6791 } 6792 6793 protected void composeClinicalUseDefinitionWarningComponent(Complex parent, String parentType, String name, ClinicalUseDefinition.ClinicalUseDefinitionWarningComponent element, int index) { 6794 if (element == null) 6795 return; 6796 Complex t; 6797 if (Utilities.noString(parentType)) 6798 t = parent; 6799 else { 6800 t = parent.predicate("fhir:"+name,index > -1); 6801 } 6802 composeBackboneElement(t, "warning", name, element, index); 6803 if (element.hasDescriptionElement()) { 6804 composeMarkdown(t, "ClinicalUseDefinitionWarningComponent", "description", element.getDescriptionElement(), -1); 6805 } 6806 if (element.hasCode()) { 6807 composeCodeableConcept(t, "ClinicalUseDefinitionWarningComponent", "code", element.getCode(), -1); 6808 } 6809 } 6810 6811 protected void composeCodeSystem(Complex parent, String parentType, String name, CodeSystem element, int index) { 6812 if (element == null) 6813 return; 6814 Complex t; 6815 if (Utilities.noString(parentType)) 6816 t = parent; 6817 else { 6818 t = parent.predicate("fhir:"+name,index > -1); 6819 } 6820 composeMetadataResource(t, "CodeSystem", name, element, index); 6821 if (element.hasUrlElement()) { 6822 composeUri(t, "CodeSystem", "url", element.getUrlElement(), -1); 6823 } 6824 for (int i = 0; i < element.getIdentifier().size(); i++) { 6825 composeIdentifier(t, "CodeSystem", "identifier", element.getIdentifier().get(i), i); 6826 } 6827 if (element.hasVersionElement()) { 6828 composeString(t, "CodeSystem", "version", element.getVersionElement(), -1); 6829 } 6830 if (element.hasVersionAlgorithm()) { 6831 composeType(t, "CodeSystem", "versionAlgorithm", element.getVersionAlgorithm(), -1); 6832 } 6833 if (element.hasNameElement()) { 6834 composeString(t, "CodeSystem", "name", element.getNameElement(), -1); 6835 } 6836 if (element.hasTitleElement()) { 6837 composeString(t, "CodeSystem", "title", element.getTitleElement(), -1); 6838 } 6839 if (element.hasStatusElement()) { 6840 composeEnum(t, "CodeSystem", "status", element.getStatusElement(), -1); 6841 } 6842 if (element.hasExperimentalElement()) { 6843 composeBoolean(t, "CodeSystem", "experimental", element.getExperimentalElement(), -1); 6844 } 6845 if (element.hasDateElement()) { 6846 composeDateTime(t, "CodeSystem", "date", element.getDateElement(), -1); 6847 } 6848 if (element.hasPublisherElement()) { 6849 composeString(t, "CodeSystem", "publisher", element.getPublisherElement(), -1); 6850 } 6851 for (int i = 0; i < element.getContact().size(); i++) { 6852 composeContactDetail(t, "CodeSystem", "contact", element.getContact().get(i), i); 6853 } 6854 if (element.hasDescriptionElement()) { 6855 composeMarkdown(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 6856 } 6857 for (int i = 0; i < element.getUseContext().size(); i++) { 6858 composeUsageContext(t, "CodeSystem", "useContext", element.getUseContext().get(i), i); 6859 } 6860 for (int i = 0; i < element.getJurisdiction().size(); i++) { 6861 composeCodeableConcept(t, "CodeSystem", "jurisdiction", element.getJurisdiction().get(i), i); 6862 } 6863 if (element.hasPurposeElement()) { 6864 composeMarkdown(t, "CodeSystem", "purpose", element.getPurposeElement(), -1); 6865 } 6866 if (element.hasCopyrightElement()) { 6867 composeMarkdown(t, "CodeSystem", "copyright", element.getCopyrightElement(), -1); 6868 } 6869 if (element.hasCopyrightLabelElement()) { 6870 composeString(t, "CodeSystem", "copyrightLabel", element.getCopyrightLabelElement(), -1); 6871 } 6872 if (element.hasApprovalDateElement()) { 6873 composeDate(t, "CodeSystem", "approvalDate", element.getApprovalDateElement(), -1); 6874 } 6875 if (element.hasLastReviewDateElement()) { 6876 composeDate(t, "CodeSystem", "lastReviewDate", element.getLastReviewDateElement(), -1); 6877 } 6878 if (element.hasEffectivePeriod()) { 6879 composePeriod(t, "CodeSystem", "effectivePeriod", element.getEffectivePeriod(), -1); 6880 } 6881 for (int i = 0; i < element.getTopic().size(); i++) { 6882 composeCodeableConcept(t, "CodeSystem", "topic", element.getTopic().get(i), i); 6883 } 6884 for (int i = 0; i < element.getAuthor().size(); i++) { 6885 composeContactDetail(t, "CodeSystem", "author", element.getAuthor().get(i), i); 6886 } 6887 for (int i = 0; i < element.getEditor().size(); i++) { 6888 composeContactDetail(t, "CodeSystem", "editor", element.getEditor().get(i), i); 6889 } 6890 for (int i = 0; i < element.getReviewer().size(); i++) { 6891 composeContactDetail(t, "CodeSystem", "reviewer", element.getReviewer().get(i), i); 6892 } 6893 for (int i = 0; i < element.getEndorser().size(); i++) { 6894 composeContactDetail(t, "CodeSystem", "endorser", element.getEndorser().get(i), i); 6895 } 6896 for (int i = 0; i < element.getRelatedArtifact().size(); i++) { 6897 composeRelatedArtifact(t, "CodeSystem", "relatedArtifact", element.getRelatedArtifact().get(i), i); 6898 } 6899 if (element.hasCaseSensitiveElement()) { 6900 composeBoolean(t, "CodeSystem", "caseSensitive", element.getCaseSensitiveElement(), -1); 6901 } 6902 if (element.hasValueSetElement()) { 6903 composeCanonical(t, "CodeSystem", "valueSet", element.getValueSetElement(), -1); 6904 } 6905 if (element.hasHierarchyMeaningElement()) { 6906 composeEnum(t, "CodeSystem", "hierarchyMeaning", element.getHierarchyMeaningElement(), -1); 6907 } 6908 if (element.hasCompositionalElement()) { 6909 composeBoolean(t, "CodeSystem", "compositional", element.getCompositionalElement(), -1); 6910 } 6911 if (element.hasVersionNeededElement()) { 6912 composeBoolean(t, "CodeSystem", "versionNeeded", element.getVersionNeededElement(), -1); 6913 } 6914 if (element.hasContentElement()) { 6915 composeEnum(t, "CodeSystem", "content", element.getContentElement(), -1); 6916 } 6917 if (element.hasSupplementsElement()) { 6918 composeCanonical(t, "CodeSystem", "supplements", element.getSupplementsElement(), -1); 6919 } 6920 if (element.hasCountElement()) { 6921 composeUnsignedInt(t, "CodeSystem", "count", element.getCountElement(), -1); 6922 } 6923 for (int i = 0; i < element.getFilter().size(); i++) { 6924 composeCodeSystemFilterComponent(t, "CodeSystem", "filter", element.getFilter().get(i), i); 6925 } 6926 for (int i = 0; i < element.getProperty().size(); i++) { 6927 composeCodeSystemPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i); 6928 } 6929 for (int i = 0; i < element.getConcept().size(); i++) { 6930 composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i); 6931 } 6932 } 6933 6934 protected void composeCodeSystemFilterComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemFilterComponent element, int index) { 6935 if (element == null) 6936 return; 6937 Complex t; 6938 if (Utilities.noString(parentType)) 6939 t = parent; 6940 else { 6941 t = parent.predicate("fhir:"+name,index > -1); 6942 } 6943 composeBackboneElement(t, "filter", name, element, index); 6944 if (element.hasCodeElement()) { 6945 composeCode(t, "CodeSystemFilterComponent", "code", element.getCodeElement(), -1); 6946 } 6947 if (element.hasDescriptionElement()) { 6948 composeString(t, "CodeSystemFilterComponent", "description", element.getDescriptionElement(), -1); 6949 } 6950 for (int i = 0; i < element.getOperator().size(); i++) { 6951 composeEnum(t, "CodeSystemFilterComponent", "operator", element.getOperator().get(i), i); 6952 } 6953 if (element.hasValueElement()) { 6954 composeString(t, "CodeSystemFilterComponent", "value", element.getValueElement(), -1); 6955 } 6956 } 6957 6958 protected void composeCodeSystemPropertyComponent(Complex parent, String parentType, String name, CodeSystem.PropertyComponent element, int index) { 6959 if (element == null) 6960 return; 6961 Complex t; 6962 if (Utilities.noString(parentType)) 6963 t = parent; 6964 else { 6965 t = parent.predicate("fhir:"+name,index > -1); 6966 } 6967 composeBackboneElement(t, "property", name, element, index); 6968 if (element.hasCodeElement()) { 6969 composeCode(t, "PropertyComponent", "code", element.getCodeElement(), -1); 6970 } 6971 if (element.hasUriElement()) { 6972 composeUri(t, "PropertyComponent", "uri", element.getUriElement(), -1); 6973 } 6974 if (element.hasDescriptionElement()) { 6975 composeString(t, "PropertyComponent", "description", element.getDescriptionElement(), -1); 6976 } 6977 if (element.hasTypeElement()) { 6978 composeEnum(t, "PropertyComponent", "type", element.getTypeElement(), -1); 6979 } 6980 } 6981 6982 protected void composeCodeSystemConceptDefinitionComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionComponent element, int index) { 6983 if (element == null) 6984 return; 6985 Complex t; 6986 if (Utilities.noString(parentType)) 6987 t = parent; 6988 else { 6989 t = parent.predicate("fhir:"+name,index > -1); 6990 } 6991 composeBackboneElement(t, "concept", name, element, index); 6992 if (element.hasCodeElement()) { 6993 composeCode(t, "ConceptDefinitionComponent", "code", element.getCodeElement(), -1); 6994 } 6995 if (element.hasDisplayElement()) { 6996 composeString(t, "ConceptDefinitionComponent", "display", element.getDisplayElement(), -1); 6997 } 6998 if (element.hasDefinitionElement()) { 6999 composeString(t, "ConceptDefinitionComponent", "definition", element.getDefinitionElement(), -1); 7000 } 7001 for (int i = 0; i < element.getDesignation().size(); i++) { 7002 composeCodeSystemConceptDefinitionDesignationComponent(t, "ConceptDefinitionComponent", "designation", element.getDesignation().get(i), i); 7003 } 7004 for (int i = 0; i < element.getProperty().size(); i++) { 7005 composeCodeSystemConceptPropertyComponent(t, "ConceptDefinitionComponent", "property", element.getProperty().get(i), i); 7006 } 7007 for (int i = 0; i < element.getConcept().size(); i++) { 7008 composeCodeSystemConceptDefinitionComponent(t, "ConceptDefinitionComponent", "concept", element.getConcept().get(i), i); 7009 } 7010 } 7011 7012 protected void composeCodeSystemConceptDefinitionDesignationComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionDesignationComponent element, int index) { 7013 if (element == null) 7014 return; 7015 Complex t; 7016 if (Utilities.noString(parentType)) 7017 t = parent; 7018 else { 7019 t = parent.predicate("fhir:"+name,index > -1); 7020 } 7021 composeBackboneElement(t, "designation", name, element, index); 7022 if (element.hasLanguageElement()) { 7023 composeCode(t, "ConceptDefinitionDesignationComponent", "language", element.getLanguageElement(), -1); 7024 } 7025 if (element.hasUse()) { 7026 composeCoding(t, "ConceptDefinitionDesignationComponent", "use", element.getUse(), -1); 7027 } 7028 for (int i = 0; i < element.getAdditionalUse().size(); i++) { 7029 composeCoding(t, "ConceptDefinitionDesignationComponent", "additionalUse", element.getAdditionalUse().get(i), i); 7030 } 7031 if (element.hasValueElement()) { 7032 composeString(t, "ConceptDefinitionDesignationComponent", "value", element.getValueElement(), -1); 7033 } 7034 } 7035 7036 protected void composeCodeSystemConceptPropertyComponent(Complex parent, String parentType, String name, CodeSystem.ConceptPropertyComponent element, int index) { 7037 if (element == null) 7038 return; 7039 Complex t; 7040 if (Utilities.noString(parentType)) 7041 t = parent; 7042 else { 7043 t = parent.predicate("fhir:"+name,index > -1); 7044 } 7045 composeBackboneElement(t, "property", name, element, index); 7046 if (element.hasCodeElement()) { 7047 composeCode(t, "ConceptPropertyComponent", "code", element.getCodeElement(), -1); 7048 } 7049 if (element.hasValue()) { 7050 composeType(t, "ConceptPropertyComponent", "value", element.getValue(), -1); 7051 } 7052 } 7053 7054 protected void composeCommunication(Complex parent, String parentType, String name, Communication element, int index) { 7055 if (element == null) 7056 return; 7057 Complex t; 7058 if (Utilities.noString(parentType)) 7059 t = parent; 7060 else { 7061 t = parent.predicate("fhir:"+name,index > -1); 7062 } 7063 composeDomainResource(t, "Communication", name, element, index); 7064 for (int i = 0; i < element.getIdentifier().size(); i++) { 7065 composeIdentifier(t, "Communication", "identifier", element.getIdentifier().get(i), i); 7066 } 7067 for (int i = 0; i < element.getInstantiatesCanonical().size(); i++) { 7068 composeCanonical(t, "Communication", "instantiatesCanonical", element.getInstantiatesCanonical().get(i), i); 7069 } 7070 for (int i = 0; i < element.getInstantiatesUri().size(); i++) { 7071 composeUri(t, "Communication", "instantiatesUri", element.getInstantiatesUri().get(i), i); 7072 } 7073 for (int i = 0; i < element.getBasedOn().size(); i++) { 7074 composeReference(t, "Communication", "basedOn", element.getBasedOn().get(i), i); 7075 } 7076 for (int i = 0; i < element.getPartOf().size(); i++) { 7077 composeReference(t, "Communication", "partOf", element.getPartOf().get(i), i); 7078 } 7079 for (int i = 0; i < element.getInResponseTo().size(); i++) { 7080 composeReference(t, "Communication", "inResponseTo", element.getInResponseTo().get(i), i); 7081 } 7082 if (element.hasStatusElement()) { 7083 composeEnum(t, "Communication", "status", element.getStatusElement(), -1); 7084 } 7085 if (element.hasStatusReason()) { 7086 composeCodeableConcept(t, "Communication", "statusReason", element.getStatusReason(), -1); 7087 } 7088 for (int i = 0; i < element.getCategory().size(); i++) { 7089 composeCodeableConcept(t, "Communication", "category", element.getCategory().get(i), i); 7090 } 7091 if (element.hasPriorityElement()) { 7092 composeEnum(t, "Communication", "priority", element.getPriorityElement(), -1); 7093 } 7094 for (int i = 0; i < element.getMedium().size(); i++) { 7095 composeCodeableConcept(t, "Communication", "medium", element.getMedium().get(i), i); 7096 } 7097 if (element.hasSubject()) { 7098 composeReference(t, "Communication", "subject", element.getSubject(), -1); 7099 } 7100 if (element.hasTopic()) { 7101 composeCodeableConcept(t, "Communication", "topic", element.getTopic(), -1); 7102 } 7103 for (int i = 0; i < element.getAbout().size(); i++) { 7104 composeReference(t, "Communication", "about", element.getAbout().get(i), i); 7105 } 7106 if (element.hasEncounter()) { 7107 composeReference(t, "Communication", "encounter", element.getEncounter(), -1); 7108 } 7109 if (element.hasSentElement()) { 7110 composeDateTime(t, "Communication", "sent", element.getSentElement(), -1); 7111 } 7112 if (element.hasReceivedElement()) { 7113 composeDateTime(t, "Communication", "received", element.getReceivedElement(), -1); 7114 } 7115 for (int i = 0; i < element.getRecipient().size(); i++) { 7116 composeReference(t, "Communication", "recipient", element.getRecipient().get(i), i); 7117 } 7118 if (element.hasSender()) { 7119 composeReference(t, "Communication", "sender", element.getSender(), -1); 7120 } 7121 for (int i = 0; i < element.getReason().size(); i++) { 7122 composeCodeableReference(t, "Communication", "reason", element.getReason().get(i), i); 7123 } 7124 for (int i = 0; i < element.getPayload().size(); i++) { 7125 composeCommunicationPayloadComponent(t, "Communication", "payload", element.getPayload().get(i), i); 7126 } 7127 for (int i = 0; i < element.getNote().size(); i++) { 7128 composeAnnotation(t, "Communication", "note", element.getNote().get(i), i); 7129 } 7130 } 7131 7132 protected void composeCommunicationPayloadComponent(Complex parent, String parentType, String name, Communication.CommunicationPayloadComponent element, int index) { 7133 if (element == null) 7134 return; 7135 Complex t; 7136 if (Utilities.noString(parentType)) 7137 t = parent; 7138 else { 7139 t = parent.predicate("fhir:"+name,index > -1); 7140 } 7141 composeBackboneElement(t, "payload", name, element, index); 7142 if (element.hasContent()) { 7143 composeType(t, "CommunicationPayloadComponent", "content", element.getContent(), -1); 7144 } 7145 } 7146 7147 protected void composeCommunicationRequest(Complex parent, String parentType, String name, CommunicationRequest element, int index) { 7148 if (element == null) 7149 return; 7150 Complex t; 7151 if (Utilities.noString(parentType)) 7152 t = parent; 7153 else { 7154 t = parent.predicate("fhir:"+name,index > -1); 7155 } 7156 composeDomainResource(t, "CommunicationRequest", name, element, index); 7157 for (int i = 0; i < element.getIdentifier().size(); i++) { 7158 composeIdentifier(t, "CommunicationRequest", "identifier", element.getIdentifier().get(i), i); 7159 } 7160 for (int i = 0; i < element.getBasedOn().size(); i++) { 7161 composeReference(t, "CommunicationRequest", "basedOn", element.getBasedOn().get(i), i); 7162 } 7163 for (int i = 0; i < element.getReplaces().size(); i++) { 7164 composeReference(t, "CommunicationRequest", "replaces", element.getReplaces().get(i), i); 7165 } 7166 if (element.hasGroupIdentifier()) { 7167 composeIdentifier(t, "CommunicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 7168 } 7169 if (element.hasStatusElement()) { 7170 composeEnum(t, "CommunicationRequest", "status", element.getStatusElement(), -1); 7171 } 7172 if (element.hasStatusReason()) { 7173 composeCodeableConcept(t, "CommunicationRequest", "statusReason", element.getStatusReason(), -1); 7174 } 7175 if (element.hasIntentElement()) { 7176 composeEnum(t, "CommunicationRequest", "intent", element.getIntentElement(), -1); 7177 } 7178 for (int i = 0; i < element.getCategory().size(); i++) { 7179 composeCodeableConcept(t, "CommunicationRequest", "category", element.getCategory().get(i), i); 7180 } 7181 if (element.hasPriorityElement()) { 7182 composeEnum(t, "CommunicationRequest", "priority", element.getPriorityElement(), -1); 7183 } 7184 if (element.hasDoNotPerformElement()) { 7185 composeBoolean(t, "CommunicationRequest", "doNotPerform", element.getDoNotPerformElement(), -1); 7186 } 7187 for (int i = 0; i < element.getMedium().size(); i++) { 7188 composeCodeableConcept(t, "CommunicationRequest", "medium", element.getMedium().get(i), i); 7189 } 7190 if (element.hasSubject()) { 7191 composeReference(t, "CommunicationRequest", "subject", element.getSubject(), -1); 7192 } 7193 for (int i = 0; i < element.getAbout().size(); i++) { 7194 composeReference(t, "CommunicationRequest", "about", element.getAbout().get(i), i); 7195 } 7196 if (element.hasEncounter()) { 7197 composeReference(t, "CommunicationRequest", "encounter", element.getEncounter(), -1); 7198 } 7199 for (int i = 0; i < element.getPayload().size(); i++) { 7200 composeCommunicationRequestPayloadComponent(t, "CommunicationRequest", "payload", element.getPayload().get(i), i); 7201 } 7202 if (element.hasOccurrence()) { 7203 composeType(t, "CommunicationRequest", "occurrence", element.getOccurrence(), -1); 7204 } 7205 if (element.hasAuthoredOnElement()) { 7206 composeDateTime(t, "CommunicationRequest", "authoredOn", element.getAuthoredOnElement(), -1); 7207 } 7208 if (element.hasRequester()) { 7209 composeReference(t, "CommunicationRequest", "requester", element.getRequester(), -1); 7210 } 7211 for (int i = 0; i < element.getRecipient().size(); i++) { 7212 composeReference(t, "CommunicationRequest", "recipient", element.getRecipient().get(i), i); 7213 } 7214 for (int i = 0; i < element.getInformationProvider().size(); i++) { 7215 composeReference(t, "CommunicationRequest", "informationProvider", element.getInformationProvider().get(i), i); 7216 } 7217 for (int i = 0; i < element.getReason().size(); i++) { 7218 composeCodeableReference(t, "CommunicationRequest", "reason", element.getReason().get(i), i); 7219 } 7220 for (int i = 0; i < element.getNote().size(); i++) { 7221 composeAnnotation(t, "CommunicationRequest", "note", element.getNote().get(i), i); 7222 } 7223 } 7224 7225 protected void composeCommunicationRequestPayloadComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestPayloadComponent element, int index) { 7226 if (element == null) 7227 return; 7228 Complex t; 7229 if (Utilities.noString(parentType)) 7230 t = parent; 7231 else { 7232 t = parent.predicate("fhir:"+name,index > -1); 7233 } 7234 composeBackboneElement(t, "payload", name, element, index); 7235 if (element.hasContent()) { 7236 composeType(t, "CommunicationRequestPayloadComponent", "content", element.getContent(), -1); 7237 } 7238 } 7239 7240 protected void composeCompartmentDefinition(Complex parent, String parentType, String name, CompartmentDefinition element, int index) { 7241 if (element == null) 7242 return; 7243 Complex t; 7244 if (Utilities.noString(parentType)) 7245 t = parent; 7246 else { 7247 t = parent.predicate("fhir:"+name,index > -1); 7248 } 7249 composeCanonicalResource(t, "CompartmentDefinition", name, element, index); 7250 if (element.hasUrlElement()) { 7251 composeUri(t, "CompartmentDefinition", "url", element.getUrlElement(), -1); 7252 } 7253 if (element.hasVersionElement()) { 7254 composeString(t, "CompartmentDefinition", "version", element.getVersionElement(), -1); 7255 } 7256 if (element.hasVersionAlgorithm()) { 7257 composeType(t, "CompartmentDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1); 7258 } 7259 if (element.hasNameElement()) { 7260 composeString(t, "CompartmentDefinition", "name", element.getNameElement(), -1); 7261 } 7262 if (element.hasTitleElement()) { 7263 composeString(t, "CompartmentDefinition", "title", element.getTitleElement(), -1); 7264 } 7265 if (element.hasStatusElement()) { 7266 composeEnum(t, "CompartmentDefinition", "status", element.getStatusElement(), -1); 7267 } 7268 if (element.hasExperimentalElement()) { 7269 composeBoolean(t, "CompartmentDefinition", "experimental", element.getExperimentalElement(), -1); 7270 } 7271 if (element.hasDateElement()) { 7272 composeDateTime(t, "CompartmentDefinition", "date", element.getDateElement(), -1); 7273 } 7274 if (element.hasPublisherElement()) { 7275 composeString(t, "CompartmentDefinition", "publisher", element.getPublisherElement(), -1); 7276 } 7277 for (int i = 0; i < element.getContact().size(); i++) { 7278 composeContactDetail(t, "CompartmentDefinition", "contact", element.getContact().get(i), i); 7279 } 7280 if (element.hasDescriptionElement()) { 7281 composeMarkdown(t, "CompartmentDefinition", "description", element.getDescriptionElement(), -1); 7282 } 7283 for (int i = 0; i < element.getUseContext().size(); i++) { 7284 composeUsageContext(t, "CompartmentDefinition", "useContext", element.getUseContext().get(i), i); 7285 } 7286 if (element.hasPurposeElement()) { 7287 composeMarkdown(t, "CompartmentDefinition", "purpose", element.getPurposeElement(), -1); 7288 } 7289 if (element.hasCodeElement()) { 7290 composeEnum(t, "CompartmentDefinition", "code", element.getCodeElement(), -1); 7291 } 7292 if (element.hasSearchElement()) { 7293 composeBoolean(t, "CompartmentDefinition", "search", element.getSearchElement(), -1); 7294 } 7295 for (int i = 0; i < element.getResource().size(); i++) { 7296 composeCompartmentDefinitionResourceComponent(t, "CompartmentDefinition", "resource", element.getResource().get(i), i); 7297 } 7298 } 7299 7300 protected void composeCompartmentDefinitionResourceComponent(Complex parent, String parentType, String name, CompartmentDefinition.CompartmentDefinitionResourceComponent element, int index) { 7301 if (element == null) 7302 return; 7303 Complex t; 7304 if (Utilities.noString(parentType)) 7305 t = parent; 7306 else { 7307 t = parent.predicate("fhir:"+name,index > -1); 7308 } 7309 composeBackboneElement(t, "resource", name, element, index); 7310 if (element.hasCodeElement()) { 7311 composeCode(t, "CompartmentDefinitionResourceComponent", "code", element.getCodeElement(), -1); 7312 } 7313 for (int i = 0; i < element.getParam().size(); i++) { 7314 composeString(t, "CompartmentDefinitionResourceComponent", "param", element.getParam().get(i), i); 7315 } 7316 if (element.hasDocumentationElement()) { 7317 composeString(t, "CompartmentDefinitionResourceComponent", "documentation", element.getDocumentationElement(), -1); 7318 } 7319 if (element.hasStartParamElement()) { 7320 composeUri(t, "CompartmentDefinitionResourceComponent", "startParam", element.getStartParamElement(), -1); 7321 } 7322 if (element.hasEndParamElement()) { 7323 composeUri(t, "CompartmentDefinitionResourceComponent", "endParam", element.getEndParamElement(), -1); 7324 } 7325 } 7326 7327 protected void composeComposition(Complex parent, String parentType, String name, Composition element, int index) { 7328 if (element == null) 7329 return; 7330 Complex t; 7331 if (Utilities.noString(parentType)) 7332 t = parent; 7333 else { 7334 t = parent.predicate("fhir:"+name,index > -1); 7335 } 7336 composeDomainResource(t, "Composition", name, element, index); 7337 if (element.hasUrlElement()) { 7338 composeUri(t, "Composition", "url", element.getUrlElement(), -1); 7339 } 7340 for (int i = 0; i < element.getIdentifier().size(); i++) { 7341 composeIdentifier(t, "Composition", "identifier", element.getIdentifier().get(i), i); 7342 } 7343 if (element.hasVersionElement()) { 7344 composeString(t, "Composition", "version", element.getVersionElement(), -1); 7345 } 7346 if (element.hasStatusElement()) { 7347 composeEnum(t, "Composition", "status", element.getStatusElement(), -1); 7348 } 7349 if (element.hasType()) { 7350 composeCodeableConcept(t, "Composition", "type", element.getType(), -1); 7351 } 7352 for (int i = 0; i < element.getCategory().size(); i++) { 7353 composeCodeableConcept(t, "Composition", "category", element.getCategory().get(i), i); 7354 } 7355 for (int i = 0; i < element.getSubject().size(); i++) { 7356 composeReference(t, "Composition", "subject", element.getSubject().get(i), i); 7357 } 7358 if (element.hasEncounter()) { 7359 composeReference(t, "Composition", "encounter", element.getEncounter(), -1); 7360 } 7361 if (element.hasDateElement()) { 7362 composeDateTime(t, "Composition", "date", element.getDateElement(), -1); 7363 } 7364 for (int i = 0; i < element.getUseContext().size(); i++) { 7365 composeUsageContext(t, "Composition", "useContext", element.getUseContext().get(i), i); 7366 } 7367 for (int i = 0; i < element.getAuthor().size(); i++) { 7368 composeReference(t, "Composition", "author", element.getAuthor().get(i), i); 7369 } 7370 if (element.hasNameElement()) { 7371 composeString(t, "Composition", "name", element.getNameElement(), -1); 7372 } 7373 if (element.hasTitleElement()) { 7374 composeString(t, "Composition", "title", element.getTitleElement(), -1); 7375 } 7376 for (int i = 0; i < element.getNote().size(); i++) { 7377 composeAnnotation(t, "Composition", "note", element.getNote().get(i), i); 7378 } 7379 for (int i = 0; i < element.getAttester().size(); i++) { 7380 composeCompositionAttesterComponent(t, "Composition", "attester", element.getAttester().get(i), i); 7381 } 7382 if (element.hasCustodian()) { 7383 composeReference(t, "Composition", "custodian", element.getCustodian(), -1); 7384 } 7385 for (int i = 0; i < element.getRelatesTo().size(); i++) { 7386 composeRelatedArtifact(t, "Composition", "relatesTo", element.getRelatesTo().get(i), i); 7387 } 7388 for (int i = 0; i < element.getEvent().size(); i++) { 7389 composeCompositionEventComponent(t, "Composition", "event", element.getEvent().get(i), i); 7390 } 7391 for (int i = 0; i < element.getSection().size(); i++) { 7392 composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i); 7393 } 7394 } 7395 7396 protected void composeCompositionAttesterComponent(Complex parent, String parentType, String name, Composition.CompositionAttesterComponent element, int index) { 7397 if (element == null) 7398 return; 7399 Complex t; 7400 if (Utilities.noString(parentType)) 7401 t = parent; 7402 else { 7403 t = parent.predicate("fhir:"+name,index > -1); 7404 } 7405 composeBackboneElement(t, "attester", name, element, index); 7406 if (element.hasMode()) { 7407 composeCodeableConcept(t, "CompositionAttesterComponent", "mode", element.getMode(), -1); 7408 } 7409 if (element.hasTimeElement()) { 7410 composeDateTime(t, "CompositionAttesterComponent", "time", element.getTimeElement(), -1); 7411 } 7412 if (element.hasParty()) { 7413 composeReference(t, "CompositionAttesterComponent", "party", element.getParty(), -1); 7414 } 7415 } 7416 7417 protected void composeCompositionEventComponent(Complex parent, String parentType, String name, Composition.CompositionEventComponent element, int index) { 7418 if (element == null) 7419 return; 7420 Complex t; 7421 if (Utilities.noString(parentType)) 7422 t = parent; 7423 else { 7424 t = parent.predicate("fhir:"+name,index > -1); 7425 } 7426 composeBackboneElement(t, "event", name, element, index); 7427 if (element.hasPeriod()) { 7428 composePeriod(t, "CompositionEventComponent", "period", element.getPeriod(), -1); 7429 } 7430 for (int i = 0; i < element.getDetail().size(); i++) { 7431 composeCodeableReference(t, "CompositionEventComponent", "detail", element.getDetail().get(i), i); 7432 } 7433 } 7434 7435 protected void composeCompositionSectionComponent(Complex parent, String parentType, String name, Composition.SectionComponent element, int index) { 7436 if (element == null) 7437 return; 7438 Complex t; 7439 if (Utilities.noString(parentType)) 7440 t = parent; 7441 else { 7442 t = parent.predicate("fhir:"+name,index > -1); 7443 } 7444 composeBackboneElement(t, "section", name, element, index); 7445 if (element.hasTitleElement()) { 7446 composeString(t, "SectionComponent", "title", element.getTitleElement(), -1); 7447 } 7448 if (element.hasCode()) { 7449 composeCodeableConcept(t, "SectionComponent", "code", element.getCode(), -1); 7450 } 7451 for (int i = 0; i < element.getAuthor().size(); i++) { 7452 composeReference(t, "SectionComponent", "author", element.getAuthor().get(i), i); 7453 } 7454 if (element.hasFocus()) { 7455 composeReference(t, "SectionComponent", "focus", element.getFocus(), -1); 7456 } 7457 if (element.hasText()) { 7458 composeNarrative(t, "SectionComponent", "text", element.getText(), -1); 7459 } 7460 if (element.hasOrderedBy()) { 7461 composeCodeableConcept(t, "SectionComponent", "orderedBy", element.getOrderedBy(), -1); 7462 } 7463 for (int i = 0; i < element.getEntry().size(); i++) { 7464 composeReference(t, "SectionComponent", "entry", element.getEntry().get(i), i); 7465 } 7466 if (element.hasEmptyReason()) { 7467 composeCodeableConcept(t, "SectionComponent", "emptyReason", element.getEmptyReason(), -1); 7468 } 7469 for (int i = 0; i < element.getSection().size(); i++) { 7470 composeCompositionSectionComponent(t, "SectionComponent", "section", element.getSection().get(i), i); 7471 } 7472 } 7473 7474 protected void composeConceptMap(Complex parent, String parentType, String name, ConceptMap element, int index) { 7475 if (element == null) 7476 return; 7477 Complex t; 7478 if (Utilities.noString(parentType)) 7479 t = parent; 7480 else { 7481 t = parent.predicate("fhir:"+name,index > -1); 7482 } 7483 composeMetadataResource(t, "ConceptMap", name, element, index); 7484 if (element.hasUrlElement()) { 7485 composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1); 7486 } 7487 for (int i = 0; i < element.getIdentifier().size(); i++) { 7488 composeIdentifier(t, "ConceptMap", "identifier", element.getIdentifier().get(i), i); 7489 } 7490 if (element.hasVersionElement()) { 7491 composeString(t, "ConceptMap", "version", element.getVersionElement(), -1); 7492 } 7493 if (element.hasVersionAlgorithm()) { 7494 composeType(t, "ConceptMap", "versionAlgorithm", element.getVersionAlgorithm(), -1); 7495 } 7496 if (element.hasNameElement()) { 7497 composeString(t, "ConceptMap", "name", element.getNameElement(), -1); 7498 } 7499 if (element.hasTitleElement()) { 7500 composeString(t, "ConceptMap", "title", element.getTitleElement(), -1); 7501 } 7502 if (element.hasStatusElement()) { 7503 composeEnum(t, "ConceptMap", "status", element.getStatusElement(), -1); 7504 } 7505 if (element.hasExperimentalElement()) { 7506 composeBoolean(t, "ConceptMap", "experimental", element.getExperimentalElement(), -1); 7507 } 7508 if (element.hasDateElement()) { 7509 composeDateTime(t, "ConceptMap", "date", element.getDateElement(), -1); 7510 } 7511 if (element.hasPublisherElement()) { 7512 composeString(t, "ConceptMap", "publisher", element.getPublisherElement(), -1); 7513 } 7514 for (int i = 0; i < element.getContact().size(); i++) { 7515 composeContactDetail(t, "ConceptMap", "contact", element.getContact().get(i), i); 7516 } 7517 if (element.hasDescriptionElement()) { 7518 composeMarkdown(t, "ConceptMap", "description", element.getDescriptionElement(), -1); 7519 } 7520 for (int i = 0; i < element.getUseContext().size(); i++) { 7521 composeUsageContext(t, "ConceptMap", "useContext", element.getUseContext().get(i), i); 7522 } 7523 for (int i = 0; i < element.getJurisdiction().size(); i++) { 7524 composeCodeableConcept(t, "ConceptMap", "jurisdiction", element.getJurisdiction().get(i), i); 7525 } 7526 if (element.hasPurposeElement()) { 7527 composeMarkdown(t, "ConceptMap", "purpose", element.getPurposeElement(), -1); 7528 } 7529 if (element.hasCopyrightElement()) { 7530 composeMarkdown(t, "ConceptMap", "copyright", element.getCopyrightElement(), -1); 7531 } 7532 if (element.hasCopyrightLabelElement()) { 7533 composeString(t, "ConceptMap", "copyrightLabel", element.getCopyrightLabelElement(), -1); 7534 } 7535 if (element.hasApprovalDateElement()) { 7536 composeDate(t, "ConceptMap", "approvalDate", element.getApprovalDateElement(), -1); 7537 } 7538 if (element.hasLastReviewDateElement()) { 7539 composeDate(t, "ConceptMap", "lastReviewDate", element.getLastReviewDateElement(), -1); 7540 } 7541 if (element.hasEffectivePeriod()) { 7542 composePeriod(t, "ConceptMap", "effectivePeriod", element.getEffectivePeriod(), -1); 7543 } 7544 for (int i = 0; i < element.getTopic().size(); i++) { 7545 composeCodeableConcept(t, "ConceptMap", "topic", element.getTopic().get(i), i); 7546 } 7547 for (int i = 0; i < element.getAuthor().size(); i++) { 7548 composeContactDetail(t, "ConceptMap", "author", element.getAuthor().get(i), i); 7549 } 7550 for (int i = 0; i < element.getEditor().size(); i++) { 7551 composeContactDetail(t, "ConceptMap", "editor", element.getEditor().get(i), i); 7552 } 7553 for (int i = 0; i < element.getReviewer().size(); i++) { 7554 composeContactDetail(t, "ConceptMap", "reviewer", element.getReviewer().get(i), i); 7555 } 7556 for (int i = 0; i < element.getEndorser().size(); i++) { 7557 composeContactDetail(t, "ConceptMap", "endorser", element.getEndorser().get(i), i); 7558 } 7559 for (int i = 0; i < element.getRelatedArtifact().size(); i++) { 7560 composeRelatedArtifact(t, "ConceptMap", "relatedArtifact", element.getRelatedArtifact().get(i), i); 7561 } 7562 for (int i = 0; i < element.getProperty().size(); i++) { 7563 composeConceptMapPropertyComponent(t, "ConceptMap", "property", element.getProperty().get(i), i); 7564 } 7565 for (int i = 0; i < element.getAdditionalAttribute().size(); i++) { 7566 composeConceptMapAdditionalAttributeComponent(t, "ConceptMap", "additionalAttribute", element.getAdditionalAttribute().get(i), i); 7567 } 7568 if (element.hasSourceScope()) { 7569 composeType(t, "ConceptMap", "sourceScope", element.getSourceScope(), -1); 7570 } 7571 if (element.hasTargetScope()) { 7572 composeType(t, "ConceptMap", "targetScope", element.getTargetScope(), -1); 7573 } 7574 for (int i = 0; i < element.getGroup().size(); i++) { 7575 composeConceptMapGroupComponent(t, "ConceptMap", "group", element.getGroup().get(i), i); 7576 } 7577 } 7578 7579 protected void composeConceptMapPropertyComponent(Complex parent, String parentType, String name, ConceptMap.PropertyComponent element, int index) { 7580 if (element == null) 7581 return; 7582 Complex t; 7583 if (Utilities.noString(parentType)) 7584 t = parent; 7585 else { 7586 t = parent.predicate("fhir:"+name,index > -1); 7587 } 7588 composeBackboneElement(t, "property", name, element, index); 7589 if (element.hasCodeElement()) { 7590 composeCode(t, "PropertyComponent", "code", element.getCodeElement(), -1); 7591 } 7592 if (element.hasUriElement()) { 7593 composeUri(t, "PropertyComponent", "uri", element.getUriElement(), -1); 7594 } 7595 if (element.hasDescriptionElement()) { 7596 composeString(t, "PropertyComponent", "description", element.getDescriptionElement(), -1); 7597 } 7598 if (element.hasTypeElement()) { 7599 composeEnum(t, "PropertyComponent", "type", element.getTypeElement(), -1); 7600 } 7601 if (element.hasSystemElement()) { 7602 composeCanonical(t, "PropertyComponent", "system", element.getSystemElement(), -1); 7603 } 7604 } 7605 7606 protected void composeConceptMapAdditionalAttributeComponent(Complex parent, String parentType, String name, ConceptMap.AdditionalAttributeComponent element, int index) { 7607 if (element == null) 7608 return; 7609 Complex t; 7610 if (Utilities.noString(parentType)) 7611 t = parent; 7612 else { 7613 t = parent.predicate("fhir:"+name,index > -1); 7614 } 7615 composeBackboneElement(t, "additionalAttribute", name, element, index); 7616 if (element.hasCodeElement()) { 7617 composeCode(t, "AdditionalAttributeComponent", "code", element.getCodeElement(), -1); 7618 } 7619 if (element.hasUriElement()) { 7620 composeUri(t, "AdditionalAttributeComponent", "uri", element.getUriElement(), -1); 7621 } 7622 if (element.hasDescriptionElement()) { 7623 composeString(t, "AdditionalAttributeComponent", "description", element.getDescriptionElement(), -1); 7624 } 7625 if (element.hasTypeElement()) { 7626 composeEnum(t, "AdditionalAttributeComponent", "type", element.getTypeElement(), -1); 7627 } 7628 } 7629 7630 protected void composeConceptMapGroupComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupComponent element, int index) { 7631 if (element == null) 7632 return; 7633 Complex t; 7634 if (Utilities.noString(parentType)) 7635 t = parent; 7636 else { 7637 t = parent.predicate("fhir:"+name,index > -1); 7638 } 7639 composeBackboneElement(t, "group", name, element, index); 7640 if (element.hasSourceElement()) { 7641 composeCanonical(t, "ConceptMapGroupComponent", "source", element.getSourceElement(), -1); 7642 } 7643 if (element.hasTargetElement()) { 7644 composeCanonical(t, "ConceptMapGroupComponent", "target", element.getTargetElement(), -1); 7645 } 7646 for (int i = 0; i < element.getElement().size(); i++) { 7647 composeConceptMapSourceElementComponent(t, "ConceptMapGroupComponent", "element", element.getElement().get(i), i); 7648 } 7649 if (element.hasUnmapped()) { 7650 composeConceptMapGroupUnmappedComponent(t, "ConceptMapGroupComponent", "unmapped", element.getUnmapped(), -1); 7651 } 7652 } 7653 7654 protected void composeConceptMapSourceElementComponent(Complex parent, String parentType, String name, ConceptMap.SourceElementComponent element, int index) { 7655 if (element == null) 7656 return; 7657 Complex t; 7658 if (Utilities.noString(parentType)) 7659 t = parent; 7660 else { 7661 t = parent.predicate("fhir:"+name,index > -1); 7662 } 7663 composeBackboneElement(t, "element", name, element, index); 7664 if (element.hasCodeElement()) { 7665 composeCode(t, "SourceElementComponent", "code", element.getCodeElement(), -1); 7666 } 7667 if (element.hasDisplayElement()) { 7668 composeString(t, "SourceElementComponent", "display", element.getDisplayElement(), -1); 7669 } 7670 if (element.hasValueSetElement()) { 7671 composeCanonical(t, "SourceElementComponent", "valueSet", element.getValueSetElement(), -1); 7672 } 7673 if (element.hasNoMapElement()) { 7674 composeBoolean(t, "SourceElementComponent", "noMap", element.getNoMapElement(), -1); 7675 } 7676 for (int i = 0; i < element.getTarget().size(); i++) { 7677 composeConceptMapTargetElementComponent(t, "SourceElementComponent", "target", element.getTarget().get(i), i); 7678 } 7679 } 7680 7681 protected void composeConceptMapTargetElementComponent(Complex parent, String parentType, String name, ConceptMap.TargetElementComponent element, int index) { 7682 if (element == null) 7683 return; 7684 Complex t; 7685 if (Utilities.noString(parentType)) 7686 t = parent; 7687 else { 7688 t = parent.predicate("fhir:"+name,index > -1); 7689 } 7690 composeBackboneElement(t, "target", name, element, index); 7691 if (element.hasCodeElement()) { 7692 composeCode(t, "TargetElementComponent", "code", element.getCodeElement(), -1); 7693 } 7694 if (element.hasDisplayElement()) { 7695 composeString(t, "TargetElementComponent", "display", element.getDisplayElement(), -1); 7696 } 7697 if (element.hasValueSetElement()) { 7698 composeCanonical(t, "TargetElementComponent", "valueSet", element.getValueSetElement(), -1); 7699 } 7700 if (element.hasRelationshipElement()) { 7701 composeEnum(t, "TargetElementComponent", "relationship", element.getRelationshipElement(), -1); 7702 } 7703 if (element.hasCommentElement()) { 7704 composeString(t, "TargetElementComponent", "comment", element.getCommentElement(), -1); 7705 } 7706 for (int i = 0; i < element.getProperty().size(); i++) { 7707 composeConceptMapMappingPropertyComponent(t, "TargetElementComponent", "property", element.getProperty().get(i), i); 7708 } 7709 for (int i = 0; i < element.getDependsOn().size(); i++) { 7710 composeConceptMapOtherElementComponent(t, "TargetElementComponent", "dependsOn", element.getDependsOn().get(i), i); 7711 } 7712 for (int i = 0; i < element.getProduct().size(); i++) { 7713 composeConceptMapOtherElementComponent(t, "TargetElementComponent", "product", element.getProduct().get(i), i); 7714 } 7715 } 7716 7717 protected void composeConceptMapMappingPropertyComponent(Complex parent, String parentType, String name, ConceptMap.MappingPropertyComponent element, int index) { 7718 if (element == null) 7719 return; 7720 Complex t; 7721 if (Utilities.noString(parentType)) 7722 t = parent; 7723 else { 7724 t = parent.predicate("fhir:"+name,index > -1); 7725 } 7726 composeBackboneElement(t, "property", name, element, index); 7727 if (element.hasCodeElement()) { 7728 composeCode(t, "MappingPropertyComponent", "code", element.getCodeElement(), -1); 7729 } 7730 if (element.hasValue()) { 7731 composeType(t, "MappingPropertyComponent", "value", element.getValue(), -1); 7732 } 7733 } 7734 7735 protected void composeConceptMapOtherElementComponent(Complex parent, String parentType, String name, ConceptMap.OtherElementComponent element, int index) { 7736 if (element == null) 7737 return; 7738 Complex t; 7739 if (Utilities.noString(parentType)) 7740 t = parent; 7741 else { 7742 t = parent.predicate("fhir:"+name,index > -1); 7743 } 7744 composeBackboneElement(t, "dependsOn", name, element, index); 7745 if (element.hasAttributeElement()) { 7746 composeCode(t, "OtherElementComponent", "attribute", element.getAttributeElement(), -1); 7747 } 7748 if (element.hasValue()) { 7749 composeType(t, "OtherElementComponent", "value", element.getValue(), -1); 7750 } 7751 if (element.hasValueSetElement()) { 7752 composeCanonical(t, "OtherElementComponent", "valueSet", element.getValueSetElement(), -1); 7753 } 7754 } 7755 7756 protected void composeConceptMapGroupUnmappedComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupUnmappedComponent element, int index) { 7757 if (element == null) 7758 return; 7759 Complex t; 7760 if (Utilities.noString(parentType)) 7761 t = parent; 7762 else { 7763 t = parent.predicate("fhir:"+name,index > -1); 7764 } 7765 composeBackboneElement(t, "unmapped", name, element, index); 7766 if (element.hasModeElement()) { 7767 composeEnum(t, "ConceptMapGroupUnmappedComponent", "mode", element.getModeElement(), -1); 7768 } 7769 if (element.hasCodeElement()) { 7770 composeCode(t, "ConceptMapGroupUnmappedComponent", "code", element.getCodeElement(), -1); 7771 } 7772 if (element.hasDisplayElement()) { 7773 composeString(t, "ConceptMapGroupUnmappedComponent", "display", element.getDisplayElement(), -1); 7774 } 7775 if (element.hasValueSetElement()) { 7776 composeCanonical(t, "ConceptMapGroupUnmappedComponent", "valueSet", element.getValueSetElement(), -1); 7777 } 7778 if (element.hasRelationshipElement()) { 7779 composeEnum(t, "ConceptMapGroupUnmappedComponent", "relationship", element.getRelationshipElement(), -1); 7780 } 7781 if (element.hasOtherMapElement()) { 7782 composeCanonical(t, "ConceptMapGroupUnmappedComponent", "otherMap", element.getOtherMapElement(), -1); 7783 } 7784 } 7785 7786 protected void composeCondition(Complex parent, String parentType, String name, Condition element, int index) { 7787 if (element == null) 7788 return; 7789 Complex t; 7790 if (Utilities.noString(parentType)) 7791 t = parent; 7792 else { 7793 t = parent.predicate("fhir:"+name,index > -1); 7794 } 7795 composeDomainResource(t, "Condition", name, element, index); 7796 for (int i = 0; i < element.getIdentifier().size(); i++) { 7797 composeIdentifier(t, "Condition", "identifier", element.getIdentifier().get(i), i); 7798 } 7799 if (element.hasClinicalStatus()) { 7800 composeCodeableConcept(t, "Condition", "clinicalStatus", element.getClinicalStatus(), -1); 7801 } 7802 if (element.hasVerificationStatus()) { 7803 composeCodeableConcept(t, "Condition", "verificationStatus", element.getVerificationStatus(), -1); 7804 } 7805 for (int i = 0; i < element.getCategory().size(); i++) { 7806 composeCodeableConcept(t, "Condition", "category", element.getCategory().get(i), i); 7807 } 7808 if (element.hasSeverity()) { 7809 composeCodeableConcept(t, "Condition", "severity", element.getSeverity(), -1); 7810 } 7811 if (element.hasCode()) { 7812 composeCodeableConcept(t, "Condition", "code", element.getCode(), -1); 7813 } 7814 for (int i = 0; i < element.getBodySite().size(); i++) { 7815 composeCodeableConcept(t, "Condition", "bodySite", element.getBodySite().get(i), i); 7816 } 7817 if (element.hasSubject()) { 7818 composeReference(t, "Condition", "subject", element.getSubject(), -1); 7819 } 7820 if (element.hasEncounter()) { 7821 composeReference(t, "Condition", "encounter", element.getEncounter(), -1); 7822 } 7823 if (element.hasOnset()) { 7824 composeType(t, "Condition", "onset", element.getOnset(), -1); 7825 } 7826 if (element.hasAbatement()) { 7827 composeType(t, "Condition", "abatement", element.getAbatement(), -1); 7828 } 7829 if (element.hasRecordedDateElement()) { 7830 composeDateTime(t, "Condition", "recordedDate", element.getRecordedDateElement(), -1); 7831 } 7832 for (int i = 0; i < element.getParticipant().size(); i++) { 7833 composeConditionParticipantComponent(t, "Condition", "participant", element.getParticipant().get(i), i); 7834 } 7835 for (int i = 0; i < element.getStage().size(); i++) { 7836 composeConditionStageComponent(t, "Condition", "stage", element.getStage().get(i), i); 7837 } 7838 for (int i = 0; i < element.getEvidence().size(); i++) { 7839 composeCodeableReference(t, "Condition", "evidence", element.getEvidence().get(i), i); 7840 } 7841 for (int i = 0; i < element.getNote().size(); i++) { 7842 composeAnnotation(t, "Condition", "note", element.getNote().get(i), i); 7843 } 7844 } 7845 7846 protected void composeConditionParticipantComponent(Complex parent, String parentType, String name, Condition.ConditionParticipantComponent element, int index) { 7847 if (element == null) 7848 return; 7849 Complex t; 7850 if (Utilities.noString(parentType)) 7851 t = parent; 7852 else { 7853 t = parent.predicate("fhir:"+name,index > -1); 7854 } 7855 composeBackboneElement(t, "participant", name, element, index); 7856 if (element.hasFunction()) { 7857 composeCodeableConcept(t, "ConditionParticipantComponent", "function", element.getFunction(), -1); 7858 } 7859 if (element.hasActor()) { 7860 composeReference(t, "ConditionParticipantComponent", "actor", element.getActor(), -1); 7861 } 7862 } 7863 7864 protected void composeConditionStageComponent(Complex parent, String parentType, String name, Condition.ConditionStageComponent element, int index) { 7865 if (element == null) 7866 return; 7867 Complex t; 7868 if (Utilities.noString(parentType)) 7869 t = parent; 7870 else { 7871 t = parent.predicate("fhir:"+name,index > -1); 7872 } 7873 composeBackboneElement(t, "stage", name, element, index); 7874 if (element.hasSummary()) { 7875 composeCodeableConcept(t, "ConditionStageComponent", "summary", element.getSummary(), -1); 7876 } 7877 for (int i = 0; i < element.getAssessment().size(); i++) { 7878 composeReference(t, "ConditionStageComponent", "assessment", element.getAssessment().get(i), i); 7879 } 7880 if (element.hasType()) { 7881 composeCodeableConcept(t, "ConditionStageComponent", "type", element.getType(), -1); 7882 } 7883 } 7884 7885 protected void composeConditionDefinition(Complex parent, String parentType, String name, ConditionDefinition element, int index) { 7886 if (element == null) 7887 return; 7888 Complex t; 7889 if (Utilities.noString(parentType)) 7890 t = parent; 7891 else { 7892 t = parent.predicate("fhir:"+name,index > -1); 7893 } 7894 composeMetadataResource(t, "ConditionDefinition", name, element, index); 7895 if (element.hasUrlElement()) { 7896 composeUri(t, "ConditionDefinition", "url", element.getUrlElement(), -1); 7897 } 7898 for (int i = 0; i < element.getIdentifier().size(); i++) { 7899 composeIdentifier(t, "ConditionDefinition", "identifier", element.getIdentifier().get(i), i); 7900 } 7901 if (element.hasVersionElement()) { 7902 composeString(t, "ConditionDefinition", "version", element.getVersionElement(), -1); 7903 } 7904 if (element.hasVersionAlgorithm()) { 7905 composeType(t, "ConditionDefinition", "versionAlgorithm", element.getVersionAlgorithm(), -1); 7906 } 7907 if (element.hasNameElement()) { 7908 composeString(t, "ConditionDefinition", "name", element.getNameElement(), -1); 7909 } 7910 if (element.hasTitleElement()) { 7911 composeString(t, "ConditionDefinition", "title", element.getTitleElement(), -1); 7912 } 7913 if (element.hasSubtitleElement()) { 7914 composeString(t, "ConditionDefinition", "subtitle", element.getSubtitleElement(), -1); 7915 } 7916 if (element.hasStatusElement()) { 7917 composeEnum(t, "ConditionDefinition", "status", element.getStatusElement(), -1); 7918 } 7919 if (element.hasExperimentalElement()) { 7920 composeBoolean(t, "ConditionDefinition", "experimental", element.getExperimentalElement(), -1); 7921 } 7922 if (element.hasDateElement()) { 7923 composeDateTime(t, "ConditionDefinition", "date", element.getDateElement(), -1); 7924 } 7925 if (element.hasPublisherElement()) { 7926 composeString(t, "ConditionDefinition", "publisher", element.getPublisherElement(), -1); 7927 } 7928 for (int i = 0; i < element.getContact().size(); i++) { 7929 composeContactDetail(t, "ConditionDefinition", "contact", element.getContact().get(i), i); 7930 } 7931 if (element.hasDescriptionElement()) { 7932 composeMarkdown(t, "ConditionDefinition", "description", element.getDescriptionElement(), -1); 7933 } 7934 for (int i = 0; i < element.getUseContext().size(); i++) { 7935 composeUsageContext(t, "ConditionDefinition", "useContext", element.getUseContext().get(i), i); 7936 } 7937 for (int i = 0; i < element.getJurisdiction().size(); i++) { 7938 composeCodeableConcept(t, "ConditionDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 7939 } 7940 if (element.hasCode()) { 7941 composeCodeableConcept(t, "ConditionDefinition", "code", element.getCode(), -1); 7942 } 7943 if (element.hasSeverity()) { 7944 composeCodeableConcept(t, "ConditionDefinition", "severity", element.getSeverity(), -1); 7945 } 7946 if (element.hasBodySite()) { 7947 composeCodeableConcept(t, "ConditionDefinition", "bodySite", element.getBodySite(), -1); 7948 } 7949 if (element.hasStage()) { 7950 composeCodeableConcept(t, "ConditionDefinition", "stage", element.getStage(), -1); 7951 } 7952 if (element.hasHasSeverityElement()) { 7953 composeBoolean(t, "ConditionDefinition", "hasSeverity", element.getHasSeverityElement(), -1); 7954 } 7955 if (element.hasHasBodySiteElement()) { 7956 composeBoolean(t, "ConditionDefinition", "hasBodySite", element.getHasBodySiteElement(), -1); 7957 } 7958 if (element.hasHasStageElement()) { 7959 composeBoolean(t, "ConditionDefinition", "hasStage", element.getHasStageElement(), -1); 7960 } 7961 for (int i = 0; i < element.getDefinition().size(); i++) { 7962 composeUri(t, "ConditionDefinition", "definition", element.getDefinition().get(i), i); 7963 } 7964 for (int i = 0; i < element.getObservation().size(); i++) { 7965 composeConditionDefinitionObservationComponent(t, "ConditionDefinition", "observation", element.getObservation().get(i), i); 7966 } 7967 for (int i = 0; i < element.getMedication().size(); i++) { 7968 composeConditionDefinitionMedicationComponent(t, "ConditionDefinition", "medication", element.getMedication().get(i), i); 7969 } 7970 for (int i = 0; i < element.getPrecondition().size(); i++) { 7971 composeConditionDefinitionPreconditionComponent(t, "ConditionDefinition", "precondition", element.getPrecondition().get(i), i); 7972 } 7973 for (int i = 0; i < element.getTeam().size(); i++) { 7974 composeReference(t, "ConditionDefinition", "team", element.getTeam().get(i), i); 7975 } 7976 for (int i = 0; i < element.getQuestionnaire().size(); i++) { 7977 composeConditionDefinitionQuestionnaireComponent(t, "ConditionDefinition", "questionnaire", element.getQuestionnaire().get(i), i); 7978 } 7979 for (int i = 0; i < element.getPlan().size(); i++) { 7980 composeConditionDefinitionPlanComponent(t, "ConditionDefinition", "plan", element.getPlan().get(i), i); 7981 } 7982 } 7983 7984 protected void composeConditionDefinitionObservationComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionObservationComponent element, int index) { 7985 if (element == null) 7986 return; 7987 Complex t; 7988 if (Utilities.noString(parentType)) 7989 t = parent; 7990 else { 7991 t = parent.predicate("fhir:"+name,index > -1); 7992 } 7993 composeBackboneElement(t, "observation", name, element, index); 7994 if (element.hasCategory()) { 7995 composeCodeableConcept(t, "ConditionDefinitionObservationComponent", "category", element.getCategory(), -1); 7996 } 7997 if (element.hasCode()) { 7998 composeCodeableConcept(t, "ConditionDefinitionObservationComponent", "code", element.getCode(), -1); 7999 } 8000 } 8001 8002 protected void composeConditionDefinitionMedicationComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionMedicationComponent element, int index) { 8003 if (element == null) 8004 return; 8005 Complex t; 8006 if (Utilities.noString(parentType)) 8007 t = parent; 8008 else { 8009 t = parent.predicate("fhir:"+name,index > -1); 8010 } 8011 composeBackboneElement(t, "medication", name, element, index); 8012 if (element.hasCategory()) { 8013 composeCodeableConcept(t, "ConditionDefinitionMedicationComponent", "category", element.getCategory(), -1); 8014 } 8015 if (element.hasCode()) { 8016 composeCodeableConcept(t, "ConditionDefinitionMedicationComponent", "code", element.getCode(), -1); 8017 } 8018 } 8019 8020 protected void composeConditionDefinitionPreconditionComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionPreconditionComponent element, int index) { 8021 if (element == null) 8022 return; 8023 Complex t; 8024 if (Utilities.noString(parentType)) 8025 t = parent; 8026 else { 8027 t = parent.predicate("fhir:"+name,index > -1); 8028 } 8029 composeBackboneElement(t, "precondition", name, element, index); 8030 if (element.hasTypeElement()) { 8031 composeEnum(t, "ConditionDefinitionPreconditionComponent", "type", element.getTypeElement(), -1); 8032 } 8033 if (element.hasCode()) { 8034 composeCodeableConcept(t, "ConditionDefinitionPreconditionComponent", "code", element.getCode(), -1); 8035 } 8036 if (element.hasValue()) { 8037 composeType(t, "ConditionDefinitionPreconditionComponent", "value", element.getValue(), -1); 8038 } 8039 } 8040 8041 protected void composeConditionDefinitionQuestionnaireComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionQuestionnaireComponent element, int index) { 8042 if (element == null) 8043 return; 8044 Complex t; 8045 if (Utilities.noString(parentType)) 8046 t = parent; 8047 else { 8048 t = parent.predicate("fhir:"+name,index > -1); 8049 } 8050 composeBackboneElement(t, "questionnaire", name, element, index); 8051 if (element.hasPurposeElement()) { 8052 composeEnum(t, "ConditionDefinitionQuestionnaireComponent", "purpose", element.getPurposeElement(), -1); 8053 } 8054 if (element.hasReference()) { 8055 composeReference(t, "ConditionDefinitionQuestionnaireComponent", "reference", element.getReference(), -1); 8056 } 8057 } 8058 8059 protected void composeConditionDefinitionPlanComponent(Complex parent, String parentType, String name, ConditionDefinition.ConditionDefinitionPlanComponent element, int index) { 8060 if (element == null) 8061 return; 8062 Complex t; 8063 if (Utilities.noString(parentType)) 8064 t = parent; 8065 else { 8066 t = parent.predicate("fhir:"+name,index > -1); 8067 } 8068 composeBackboneElement(t, "plan", name, element, index); 8069 if (element.hasRole()) { 8070 composeCodeableConcept(t, "ConditionDefinitionPlanComponent", "role", element.getRole(), -1); 8071 } 8072 if (element.hasReference()) { 8073 composeReference(t, "ConditionDefinitionPlanComponent", "reference", element.getReference(), -1); 8074 } 8075 } 8076 8077 protected void composeConsent(Complex parent, String parentType, String name, Consent element, int index) { 8078 if (element == null) 8079 return; 8080 Complex t; 8081 if (Utilities.noString(parentType)) 8082 t = parent; 8083 else { 8084 t = parent.predicate("fhir:"+name,index > -1); 8085 } 8086 composeDomainResource(t, "Consent", name, element, index); 8087 for (int i = 0; i < element.getIdentifier().size(); i++) { 8088 composeIdentifier(t, "Consent", "identifier", element.getIdentifier().get(i), i); 8089 } 8090 if (element.hasStatusElement()) { 8091 composeEnum(t, "Consent", "status", element.getStatusElement(), -1); 8092 } 8093 for (int i = 0; i < element.getCategory().size(); i++) { 8094 composeCodeableConcept(t, "Consent", "category", element.getCategory().get(i), i); 8095 } 8096 if (element.hasSubject()) { 8097 composeReference(t, "Consent", "subject", element.getSubject(), -1); 8098 } 8099 if (element.hasDateElement()) { 8100 composeDate(t, "Consent", "date", element.getDateElement(), -1); 8101 } 8102 if (element.hasPeriod()) { 8103 composePeriod(t, "Consent", "period", element.getPeriod(), -1); 8104 } 8105 for (int i = 0; i < element.getGrantor().size(); i++) { 8106 composeReference(t, "Consent", "grantor", element.getGrantor().get(i), i); 8107 } 8108 for (int i = 0; i < element.getGrantee().size(); i++) { 8109 composeReference(t, "Consent", "grantee", element.getGrantee().get(i), i); 8110 } 8111 for (int i = 0; i < element.getManager().size(); i++) { 8112 composeReference(t, "Consent", "manager", element.getManager().get(i), i); 8113 } 8114 for (int i = 0; i < element.getController().size(); i++) { 8115 composeReference(t, "Consent", "controller", element.getController().get(i), i); 8116 } 8117 for (int i = 0; i < element.getSourceAttachment().size(); i++) { 8118 composeAttachment(t, "Consent", "sourceAttachment", element.getSourceAttachment().get(i), i); 8119 } 8120 for (int i = 0; i < element.getSourceReference().size(); i++) { 8121 composeReference(t, "Consent", "sourceReference", element.getSourceReference().get(i), i); 8122 } 8123 for (int i = 0; i < element.getRegulatoryBasis().size(); i++) { 8124 composeCodeableConcept(t, "Consent", "regulatoryBasis", element.getRegulatoryBasis().get(i), i); 8125 } 8126 if (element.hasPolicyBasis()) { 8127 composeConsentPolicyBasisComponent(t, "Consent", "policyBasis", element.getPolicyBasis(), -1); 8128 } 8129 for (int i = 0; i < element.getPolicyText().size(); i++) { 8130 composeReference(t, "Consent", "policyText", element.getPolicyText().get(i), i); 8131 } 8132 for (int i = 0; i < element.getVerification().size(); i++) { 8133 composeConsentVerificationComponent(t, "Consent", "verification", element.getVerification().get(i), i); 8134 } 8135 if (element.hasDecisionElement()) { 8136 composeEnum(t, "Consent", "decision", element.getDecisionElement(), -1); 8137 } 8138 for (int i = 0; i < element.getProvision().size(); i++) { 8139 composeConsentProvisionComponent(t, "Consent", "provision", element.getProvision().get(i), i); 8140 } 8141 } 8142 8143 protected void composeConsentPolicyBasisComponent(Complex parent, String parentType, String name, Consent.ConsentPolicyBasisComponent element, int index) { 8144 if (element == null) 8145 return; 8146 Complex t; 8147 if (Utilities.noString(parentType)) 8148 t = parent; 8149 else { 8150 t = parent.predicate("fhir:"+name,index > -1); 8151 } 8152 composeBackboneElement(t, "policyBasis", name, element, index); 8153 if (element.hasReference()) { 8154 composeReference(t, "ConsentPolicyBasisComponent", "reference", element.getReference(), -1); 8155 } 8156 if (element.hasUrlElement()) { 8157 composeUrl(t, "ConsentPolicyBasisComponent", "url", element.getUrlElement(), -1); 8158 } 8159 } 8160 8161 protected void composeConsentVerificationComponent(Complex parent, String parentType, String name, Consent.ConsentVerificationComponent element, int index) { 8162 if (element == null) 8163 return; 8164 Complex t; 8165 if (Utilities.noString(parentType)) 8166 t = parent; 8167 else { 8168 t = parent.predicate("fhir:"+name,index > -1); 8169 } 8170 composeBackboneElement(t, "verification", name, element, index); 8171 if (element.hasVerifiedElement()) { 8172 composeBoolean(t, "ConsentVerificationComponent", "verified", element.getVerifiedElement(), -1); 8173 } 8174 if (element.hasVerificationType()) { 8175 composeCodeableConcept(t, "ConsentVerificationComponent", "verificationType", element.getVerificationType(), -1); 8176 } 8177 if (element.hasVerifiedBy()) { 8178 composeReference(t, "ConsentVerificationComponent", "verifiedBy", element.getVerifiedBy(), -1); 8179 } 8180 if (element.hasVerifiedWith()) { 8181 composeReference(t, "ConsentVerificationComponent", "verifiedWith", element.getVerifiedWith(), -1); 8182 } 8183 for (int i = 0; i < element.getVerificationDate().size(); i++) { 8184 composeDateTime(t, "ConsentVerificationComponent", "verificationDate", element.getVerificationDate().get(i), i); 8185 } 8186 } 8187 8188 protected void composeConsentProvisionComponent(Complex parent, String parentType, String name, Consent.ProvisionComponent element, int index) { 8189 if (element == null) 8190 return; 8191 Complex t; 8192 if (Utilities.noString(parentType)) 8193 t = parent; 8194 else { 8195 t = parent.predicate("fhir:"+name,index > -1); 8196 } 8197 composeBackboneElement(t, "provision", name, element, index); 8198 if (element.hasPeriod()) { 8199 composePeriod(t, "ProvisionComponent", "period", element.getPeriod(), -1); 8200 } 8201 for (int i = 0; i < element.getActor().size(); i++) { 8202 composeConsentProvisionActorComponent(t, "ProvisionComponent", "actor", element.getActor().get(i), i); 8203 } 8204 for (int i = 0; i < element.getAction().size(); i++) { 8205 composeCodeableConcept(t, "ProvisionComponent", "action", element.getAction().get(i), i); 8206 } 8207 for (int i = 0; i < element.getSecurityLabel().size(); i++) { 8208 composeCoding(t, "ProvisionComponent", "securityLabel", element.getSecurityLabel().get(i), i); 8209 } 8210 for (int i = 0; i < element.getPurpose().size(); i++) { 8211 composeCoding(t, "ProvisionComponent", "purpose", element.getPurpose().get(i), i); 8212 } 8213 for (int i = 0; i < element.getDocumentType().size(); i++) { 8214 composeCoding(t, "ProvisionComponent", "documentType", element.getDocumentType().get(i), i); 8215 } 8216 for (int i = 0; i < element.getResourceType().size(); i++) { 8217 composeCoding(t, "ProvisionComponent", "resourceType", element.getResourceType().get(i), i); 8218 } 8219 for (int i = 0; i < element.getCode().size(); i++) { 8220 composeCodeableConcept(t, "ProvisionComponent", "code", element.getCode().get(i), i); 8221 } 8222 if (element.hasDataPeriod()) { 8223 composePeriod(t, "ProvisionComponent", "dataPeriod", element.getDataPeriod(), -1); 8224 } 8225 for (int i = 0; i < element.getData().size(); i++) { 8226 composeConsentProvisionDataComponent(t, "ProvisionComponent", "data", element.getData().get(i), i); 8227 } 8228 if (element.hasExpression()) { 8229 composeExpression(t, "ProvisionComponent", "expression", element.getExpression(), -1); 8230 } 8231 for (int i = 0; i < element.getProvision().size(); i++) { 8232 composeConsentProvisionComponent(t, "ProvisionComponent", "provision", element.getProvision().get(i), i); 8233 } 8234 } 8235 8236 protected void composeConsentProvisionActorComponent(Complex parent, String parentType, String name, Consent.ProvisionActorComponent element, int index) { 8237 if (element == null) 8238 return; 8239 Complex t; 8240 if (Utilities.noString(parentType)) 8241 t = parent; 8242 else { 8243 t = parent.predicate("fhir:"+name,index > -1); 8244 } 8245 composeBackboneElement(t, "actor", name, element, index); 8246 if (element.hasRole()) { 8247 composeCodeableConcept(t, "ProvisionActorComponent", "role", element.getRole(), -1); 8248 } 8249 if (element.hasReference()) { 8250 composeReference(t, "ProvisionActorComponent", "reference", element.getReference(), -1); 8251 } 8252 } 8253 8254 protected void composeConsentProvisionDataComponent(Complex parent, String parentType, String name, Consent.ProvisionDataComponent element, int index) { 8255 if (element == null) 8256 return; 8257 Complex t; 8258 if (Utilities.noString(parentType)) 8259 t = parent; 8260 else { 8261 t = parent.predicate("fhir:"+name,index > -1); 8262 } 8263 composeBackboneElement(t, "data", name, element, index); 8264 if (element.hasMeaningElement()) { 8265 composeEnum(t, "ProvisionDataComponent", "meaning", element.getMeaningElement(), -1); 8266 } 8267 if (element.hasReference()) { 8268 composeReference(t, "ProvisionDataComponent", "reference", element.getReference(), -1); 8269 } 8270 } 8271 8272 protected void composeContract(Complex parent, String parentType, String name, Contract element, int index) { 8273 if (element == null) 8274 return; 8275 Complex t; 8276 if (Utilities.noString(parentType)) 8277 t = parent; 8278 else { 8279 t = parent.predicate("fhir:"+name,index > -1); 8280 } 8281 composeDomainResource(t, "Contract", name, element, index); 8282 for (int i = 0; i < element.getIdentifier().size(); i++) { 8283 composeIdentifier(t, "Contract", "identifier", element.getIdentifier().get(i), i); 8284 } 8285 if (element.hasUrlElement()) { 8286 composeUri(t, "Contract", "url", element.getUrlElement(), -1); 8287 } 8288 if (element.hasVersionElement()) { 8289 composeString(t, "Contract", "version", element.getVersionElement(), -1); 8290 } 8291 if (element.hasStatusElement()) { 8292 composeEnum(t, "Contract", "status", element.getStatusElement(), -1); 8293 } 8294 if (element.hasLegalState()) { 8295 composeCodeableConcept(t, "Contract", "legalState", element.getLegalState(), -1); 8296 } 8297 if (element.hasInstantiatesCanonical()) { 8298 composeReference(t, "Contract", "instantiatesCanonical", element.getInstantiatesCanonical(), -1); 8299 } 8300 if (element.hasInstantiatesUriElement()) { 8301 composeUri(t, "Contract", "instantiatesUri", element.getInstantiatesUriElement(), -1); 8302 } 8303 if (element.hasContentDerivative()) { 8304 composeCodeableConcept(t, "Contract", "contentDerivative", element.getContentDerivative(), -1); 8305 } 8306 if (element.hasIssuedElement()) { 8307 composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1); 8308 } 8309 if (element.hasApplies()) { 8310 composePeriod(t, "Contract", "applies", element.getApplies(), -1); 8311 } 8312 if (element.hasExpirationType()) { 8313 composeCodeableConcept(t, "Contract", "expirationType", element.getExpirationType(), -1); 8314 } 8315 for (int i = 0; i < element.getSubject().size(); i++) { 8316 composeReference(t, "Contract", "subject", element.getSubject().get(i), i); 8317 } 8318 for (int i = 0; i < element.getAuthority().size(); i++) { 8319 composeReference(t, "Contract", "authority", element.getAuthority().get(i), i); 8320 } 8321 for (int i = 0; i < element.getDomain().size(); i++) { 8322 composeReference(t, "Contract", "domain", element.getDomain().get(i), i); 8323 } 8324 for (int i = 0; i < element.getSite().size(); i++) { 8325 composeReference(t, "Contract", "site", element.getSite().get(i), i); 8326 } 8327 if (element.hasNameElement()) { 8328 composeString(t, "Contract", "name", element.getNameElement(), -1); 8329 } 8330 if (element.hasTitleElement()) { 8331 composeString(t, "Contract", "title", element.getTitleElement(), -1); 8332 } 8333 if (element.hasSubtitleElement()) { 8334 composeString(t, "Contract", "subtitle", element.getSubtitleElement(), -1); 8335 } 8336 for (int i = 0; i < element.getAlias().size(); i++) { 8337 composeString(t, "Contract", "alias", element.getAlias().get(i), i); 8338 } 8339 if (element.hasAuthor()) { 8340 composeReference(t, "Contract", "author", element.getAuthor(), -1); 8341 } 8342 if (element.hasScope()) { 8343 composeCodeableConcept(t, "Contract", "scope", element.getScope(), -1); 8344 } 8345 if (element.hasTopic()) { 8346 composeType(t, "Contract", "topic", element.getTopic(), -1); 8347 } 8348 if (element.hasType()) { 8349 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 8350 } 8351 for (int i = 0; i < element.getSubType().size(); i++) { 8352 composeCodeableConcept(t, "Contract", "subType", element.getSubType().get(i), i); 8353 } 8354 if (element.hasContentDefinition()) { 8355 composeContractContentDefinitionComponent(t, "Contract", "contentDefinition", element.getContentDefinition(), -1); 8356 } 8357 for (int i = 0; i < element.getTerm().size(); i++) { 8358 composeContractTermComponent(t, "Contract", "term", element.getTerm().get(i), i); 8359 } 8360 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 8361 composeReference(t, "Contract", "supportingInfo", element.getSupportingInfo().get(i), i); 8362 } 8363 for (int i = 0; i < element.getRelevantHistory().size(); i++) { 8364 composeReference(t, "Contract", "relevantHistory", element.getRelevantHistory().get(i), i); 8365 } 8366 for (int i = 0; i < element.getSigner().size(); i++) { 8367 composeContractSignatoryComponent(t, "Contract", "signer", element.getSigner().get(i), i); 8368 } 8369 for (int i = 0; i < element.getFriendly().size(); i++) { 8370 composeContractFriendlyLanguageComponent(t, "Contract", "friendly", element.getFriendly().get(i), i); 8371 } 8372 for (int i = 0; i < element.getLegal().size(); i++) { 8373 composeContractLegalLanguageComponent(t, "Contract", "legal", element.getLegal().get(i), i); 8374 } 8375 for (int i = 0; i < element.getRule().size(); i++) { 8376 composeContractComputableLanguageComponent(t, "Contract", "rule", element.getRule().get(i), i); 8377 } 8378 if (element.hasLegallyBinding()) { 8379 composeType(t, "Contract", "legallyBinding", element.getLegallyBinding(), -1); 8380 } 8381 } 8382 8383 protected void composeContractContentDefinitionComponent(Complex parent, String parentType, String name, Contract.ContentDefinitionComponent element, int index) { 8384 if (element == null) 8385 return; 8386 Complex t; 8387 if (Utilities.noString(parentType)) 8388 t = parent; 8389 else { 8390 t = parent.predicate("fhir:"+name,index > -1); 8391 } 8392 composeBackboneElement(t, "contentDefinition", name, element, index); 8393 if (element.hasType()) { 8394 composeCodeableConcept(t, "ContentDefinitionComponent", "type", element.getType(), -1); 8395 } 8396 if (element.hasSubType()) { 8397 composeCodeableConcept(t, "ContentDefinitionComponent", "subType", element.getSubType(), -1); 8398 } 8399 if (element.hasPublisher()) { 8400 composeReference(t, "ContentDefinitionComponent", "publisher", element.getPublisher(), -1); 8401 } 8402 if (element.hasPublicationDateElement()) { 8403 composeDateTime(t, "ContentDefinitionComponent", "publicationDate", element.getPublicationDateElement(), -1); 8404 } 8405 if (element.hasPublicationStatusElement()) { 8406 composeEnum(t, "ContentDefinitionComponent", "publicationStatus", element.getPublicationStatusElement(), -1); 8407 } 8408 if (element.hasCopyrightElement()) { 8409 composeMarkdown(t, "ContentDefinitionComponent", "copyright", element.getCopyrightElement(), -1); 8410 } 8411 } 8412 8413 protected void composeContractTermComponent(Complex parent, String parentType, String name, Contract.TermComponent element, int index) { 8414 if (element == null) 8415 return; 8416 Complex t; 8417 if (Utilities.noString(parentType)) 8418 t = parent; 8419 else { 8420 t = parent.predicate("fhir:"+name,index > -1); 8421 } 8422 composeBackboneElement(t, "term", name, element, index); 8423 if (element.hasIdentifier()) { 8424 composeIdentifier(t, "TermComponent", "identifier", element.getIdentifier(), -1); 8425 } 8426 if (element.hasIssuedElement()) { 8427 composeDateTime(t, "TermComponent", "issued", element.getIssuedElement(), -1); 8428 } 8429 if (element.hasApplies()) { 8430 composePeriod(t, "TermComponent", "applies", element.getApplies(), -1); 8431 } 8432 if (element.hasTopic()) { 8433 composeType(t, "TermComponent", "topic", element.getTopic(), -1); 8434 } 8435 if (element.hasType()) { 8436 composeCodeableConcept(t, "TermComponent", "type", element.getType(), -1); 8437 } 8438 if (element.hasSubType()) { 8439 composeCodeableConcept(t, "TermComponent", "subType", element.getSubType(), -1); 8440 } 8441 if (element.hasTextElement()) { 8442 composeString(t, "TermComponent", "text", element.getTextElement(), -1); 8443 } 8444 for (int i = 0; i < element.getSecurityLabel().size(); i++) { 8445 composeContractSecurityLabelComponent(t, "TermComponent", "securityLabel", element.getSecurityLabel().get(i), i); 8446 } 8447 if (element.hasOffer()) { 8448 composeContractOfferComponent(t, "TermComponent", "offer", element.getOffer(), -1); 8449 } 8450 for (int i = 0; i < element.getAsset().size(); i++) { 8451 composeContractAssetComponent(t, "TermComponent", "asset", element.getAsset().get(i), i); 8452 } 8453 for (int i = 0; i < element.getAction().size(); i++) { 8454 composeContractActionComponent(t, "TermComponent", "action", element.getAction().get(i), i); 8455 } 8456 for (int i = 0; i < element.getGroup().size(); i++) { 8457 composeContractTermComponent(t, "TermComponent", "group", element.getGroup().get(i), i); 8458 } 8459 } 8460 8461 protected void composeContractSecurityLabelComponent(Complex parent, String parentType, String name, Contract.SecurityLabelComponent element, int index) { 8462 if (element == null) 8463 return; 8464 Complex t; 8465 if (Utilities.noString(parentType)) 8466 t = parent; 8467 else { 8468 t = parent.predicate("fhir:"+name,index > -1); 8469 } 8470 composeBackboneElement(t, "securityLabel", name, element, index); 8471 for (int i = 0; i < element.getNumber().size(); i++) { 8472 composeUnsignedInt(t, "SecurityLabelComponent", "number", element.getNumber().get(i), i); 8473 } 8474 if (element.hasClassification()) { 8475 composeCoding(t, "SecurityLabelComponent", "classification", element.getClassification(), -1); 8476 } 8477 for (int i = 0; i < element.getCategory().size(); i++) { 8478 composeCoding(t, "SecurityLabelComponent", "category", element.getCategory().get(i), i); 8479 } 8480 for (int i = 0; i < element.getControl().size(); i++) { 8481 composeCoding(t, "SecurityLabelComponent", "control", element.getControl().get(i), i); 8482 } 8483 } 8484 8485 protected void composeContractOfferComponent(Complex parent, String parentType, String name, Contract.ContractOfferComponent element, int index) { 8486 if (element == null) 8487 return; 8488 Complex t; 8489 if (Utilities.noString(parentType)) 8490 t = parent; 8491 else { 8492 t = parent.predicate("fhir:"+name,index > -1); 8493 } 8494 composeBackboneElement(t, "offer", name, element, index); 8495 for (int i = 0; i < element.getIdentifier().size(); i++) { 8496 composeIdentifier(t, "ContractOfferComponent", "identifier", element.getIdentifier().get(i), i); 8497 } 8498 for (int i = 0; i < element.getParty().size(); i++) { 8499 composeContractPartyComponent(t, "ContractOfferComponent", "party", element.getParty().get(i), i); 8500 } 8501 if (element.hasTopic()) { 8502 composeReference(t, "ContractOfferComponent", "topic", element.getTopic(), -1); 8503 } 8504 if (element.hasType()) { 8505 composeCodeableConcept(t, "ContractOfferComponent", "type", element.getType(), -1); 8506 } 8507 if (element.hasDecision()) { 8508 composeCodeableConcept(t, "ContractOfferComponent", "decision", element.getDecision(), -1); 8509 } 8510 for (int i = 0; i < element.getDecisionMode().size(); i++) { 8511 composeCodeableConcept(t, "ContractOfferComponent", "decisionMode", element.getDecisionMode().get(i), i); 8512 } 8513 for (int i = 0; i < element.getAnswer().size(); i++) { 8514 composeContractAnswerComponent(t, "ContractOfferComponent", "answer", element.getAnswer().get(i), i); 8515 } 8516 if (element.hasTextElement()) { 8517 composeString(t, "ContractOfferComponent", "text", element.getTextElement(), -1); 8518 } 8519 for (int i = 0; i < element.getLinkId().size(); i++) { 8520 composeString(t, "ContractOfferComponent", "linkId", element.getLinkId().get(i), i); 8521 } 8522 for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) { 8523 composeUnsignedInt(t, "ContractOfferComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i); 8524 } 8525 } 8526 8527 protected void composeContractPartyComponent(Complex parent, String parentType, String name, Contract.ContractPartyComponent element, int index) { 8528 if (element == null) 8529 return; 8530 Complex t; 8531 if (Utilities.noString(parentType)) 8532 t = parent; 8533 else { 8534 t = parent.predicate("fhir:"+name,index > -1); 8535 } 8536 composeBackboneElement(t, "party", name, element, index); 8537 for (int i = 0; i < element.getReference().size(); i++) { 8538 composeReference(t, "ContractPartyComponent", "reference", element.getReference().get(i), i); 8539 } 8540 if (element.hasRole()) { 8541 composeCodeableConcept(t, "ContractPartyComponent", "role", element.getRole(), -1); 8542 } 8543 } 8544 8545 protected void composeContractAnswerComponent(Complex parent, String parentType, String name, Contract.AnswerComponent element, int index) { 8546 if (element == null) 8547 return; 8548 Complex t; 8549 if (Utilities.noString(parentType)) 8550 t = parent; 8551 else { 8552 t = parent.predicate("fhir:"+name,index > -1); 8553 } 8554 composeBackboneElement(t, "answer", name, element, index); 8555 if (element.hasValue()) { 8556 composeType(t, "AnswerComponent", "value", element.getValue(), -1); 8557 } 8558 } 8559 8560 protected void composeContractAssetComponent(Complex parent, String parentType, String name, Contract.ContractAssetComponent element, int index) { 8561 if (element == null) 8562 return; 8563 Complex t; 8564 if (Utilities.noString(parentType)) 8565 t = parent; 8566 else { 8567 t = parent.predicate("fhir:"+name,index > -1); 8568 } 8569 composeBackboneElement(t, "asset", name, element, index); 8570 if (element.hasScope()) { 8571 composeCodeableConcept(t, "ContractAssetComponent", "scope", element.getScope(), -1); 8572 } 8573 for (int i = 0; i < element.getType().size(); i++) { 8574 composeCodeableConcept(t, "ContractAssetComponent", "type", element.getType().get(i), i); 8575 } 8576 for (int i = 0; i < element.getTypeReference().size(); i++) { 8577 composeReference(t, "ContractAssetComponent", "typeReference", element.getTypeReference().get(i), i); 8578 } 8579 for (int i = 0; i < element.getSubtype().size(); i++) { 8580 composeCodeableConcept(t, "ContractAssetComponent", "subtype", element.getSubtype().get(i), i); 8581 } 8582 if (element.hasRelationship()) { 8583 composeCoding(t, "ContractAssetComponent", "relationship", element.getRelationship(), -1); 8584 } 8585 for (int i = 0; i < element.getContext().size(); i++) { 8586 composeContractAssetContextComponent(t, "ContractAssetComponent", "context", element.getContext().get(i), i); 8587 } 8588 if (element.hasConditionElement()) { 8589 composeString(t, "ContractAssetComponent", "condition", element.getConditionElement(), -1); 8590 } 8591 for (int i = 0; i < element.getPeriodType().size(); i++) { 8592 composeCodeableConcept(t, "ContractAssetComponent", "periodType", element.getPeriodType().get(i), i); 8593 } 8594 for (int i = 0; i < element.getPeriod().size(); i++) { 8595 composePeriod(t, "ContractAssetComponent", "period", element.getPeriod().get(i), i); 8596 } 8597 for (int i = 0; i < element.getUsePeriod().size(); i++) { 8598 composePeriod(t, "ContractAssetComponent", "usePeriod", element.getUsePeriod().get(i), i); 8599 } 8600 if (element.hasTextElement()) { 8601 composeString(t, "ContractAssetComponent", "text", element.getTextElement(), -1); 8602 } 8603 for (int i = 0; i < element.getLinkId().size(); i++) { 8604 composeString(t, "ContractAssetComponent", "linkId", element.getLinkId().get(i), i); 8605 } 8606 for (int i = 0; i < element.getAnswer().size(); i++) { 8607 composeContractAnswerComponent(t, "ContractAssetComponent", "answer", element.getAnswer().get(i), i); 8608 } 8609 for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) { 8610 composeUnsignedInt(t, "ContractAssetComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i); 8611 } 8612 for (int i = 0; i < element.getValuedItem().size(); i++) { 8613 composeContractValuedItemComponent(t, "ContractAssetComponent", "valuedItem", element.getValuedItem().get(i), i); 8614 } 8615 } 8616 8617 protected void composeContractAssetContextComponent(Complex parent, String parentType, String name, Contract.AssetContextComponent element, int index) { 8618 if (element == null) 8619 return; 8620 Complex t; 8621 if (Utilities.noString(parentType)) 8622 t = parent; 8623 else { 8624 t = parent.predicate("fhir:"+name,index > -1); 8625 } 8626 composeBackboneElement(t, "context", name, element, index); 8627 if (element.hasReference()) { 8628 composeReference(t, "AssetContextComponent", "reference", element.getReference(), -1); 8629 } 8630 for (int i = 0; i < element.getCode().size(); i++) { 8631 composeCodeableConcept(t, "AssetContextComponent", "code", element.getCode().get(i), i); 8632 } 8633 if (element.hasTextElement()) { 8634 composeString(t, "AssetContextComponent", "text", element.getTextElement(), -1); 8635 } 8636 } 8637 8638 protected void composeContractValuedItemComponent(Complex parent, String parentType, String name, Contract.ValuedItemComponent element, int index) { 8639 if (element == null) 8640 return; 8641 Complex t; 8642 if (Utilities.noString(parentType)) 8643 t = parent; 8644 else { 8645 t = parent.predicate("fhir:"+name,index > -1); 8646 } 8647 composeBackboneElement(t, "valuedItem", name, element, index); 8648 if (element.hasEntity()) { 8649 composeType(t, "ValuedItemComponent", "entity", element.getEntity(), -1); 8650 } 8651 if (element.hasIdentifier()) { 8652 composeIdentifier(t, "ValuedItemComponent", "identifier", element.getIdentifier(), -1); 8653 } 8654 if (element.hasEffectiveTimeElement()) { 8655 composeDateTime(t, "ValuedItemComponent", "effectiveTime", element.getEffectiveTimeElement(), -1); 8656 } 8657 if (element.hasQuantity()) { 8658 composeQuantity(t, "ValuedItemComponent", "quantity", element.getQuantity(), -1); 8659 } 8660 if (element.hasUnitPrice()) { 8661 composeMoney(t, "ValuedItemComponent", "unitPrice", element.getUnitPrice(), -1); 8662 } 8663 if (element.hasFactorElement()) { 8664 composeDecimal(t, "ValuedItemComponent", "factor", element.getFactorElement(), -1); 8665 } 8666 if (element.hasPointsElement()) { 8667 composeDecimal(t, "ValuedItemComponent", "points", element.getPointsElement(), -1); 8668 } 8669 if (element.hasNet()) { 8670 composeMoney(t, "ValuedItemComponent", "net", element.getNet(), -1); 8671 } 8672 if (element.hasPaymentElement()) { 8673 composeString(t, "ValuedItemComponent", "payment", element.getPaymentElement(), -1); 8674 } 8675 if (element.hasPaymentDateElement()) { 8676 composeDateTime(t, "ValuedItemComponent", "paymentDate", element.getPaymentDateElement(), -1); 8677 } 8678 if (element.hasResponsible()) { 8679 composeReference(t, "ValuedItemComponent", "responsible", element.getResponsible(), -1); 8680 } 8681 if (element.hasRecipient()) { 8682 composeReference(t, "ValuedItemComponent", "recipient", element.getRecipient(), -1); 8683 } 8684 for (int i = 0; i < element.getLinkId().size(); i++) { 8685 composeString(t, "ValuedItemComponent", "linkId", element.getLinkId().get(i), i); 8686 } 8687 for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) { 8688 composeUnsignedInt(t, "ValuedItemComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i); 8689 } 8690 } 8691 8692 protected void composeContractActionComponent(Complex parent, String parentType, String name, Contract.ActionComponent element, int index) { 8693 if (element == null) 8694 return; 8695 Complex t; 8696 if (Utilities.noString(parentType)) 8697 t = parent; 8698 else { 8699 t = parent.predicate("fhir:"+name,index > -1); 8700 } 8701 composeBackboneElement(t, "action", name, element, index); 8702 if (element.hasDoNotPerformElement()) { 8703 composeBoolean(t, "ActionComponent", "doNotPerform", element.getDoNotPerformElement(), -1); 8704 } 8705 if (element.hasType()) { 8706 composeCodeableConcept(t, "ActionComponent", "type", element.getType(), -1); 8707 } 8708 for (int i = 0; i < element.getSubject().size(); i++) { 8709 composeContractActionSubjectComponent(t, "ActionComponent", "subject", element.getSubject().get(i), i); 8710 } 8711 if (element.hasIntent()) { 8712 composeCodeableConcept(t, "ActionComponent", "intent", element.getIntent(), -1); 8713 } 8714 for (int i = 0; i < element.getLinkId().size(); i++) { 8715 composeString(t, "ActionComponent", "linkId", element.getLinkId().get(i), i); 8716 } 8717 if (element.hasStatus()) { 8718 composeCodeableConcept(t, "ActionComponent", "status", element.getStatus(), -1); 8719 } 8720 if (element.hasContext()) { 8721 composeReference(t, "ActionComponent", "context", element.getContext(), -1); 8722 } 8723 for (int i = 0; i < element.getContextLinkId().size(); i++) { 8724 composeString(t, "ActionComponent", "contextLinkId", element.getContextLinkId().get(i), i); 8725 } 8726 if (element.hasOccurrence()) { 8727 composeType(t, "ActionComponent", "occurrence", element.getOccurrence(), -1); 8728 } 8729 for (int i = 0; i < element.getRequester().size(); i++) { 8730 composeReference(t, "ActionComponent", "requester", element.getRequester().get(i), i); 8731 } 8732 for (int i = 0; i < element.getRequesterLinkId().size(); i++) { 8733 composeString(t, "ActionComponent", "requesterLinkId", element.getRequesterLinkId().get(i), i); 8734 } 8735 for (int i = 0; i < element.getPerformerType().size(); i++) { 8736 composeCodeableConcept(t, "ActionComponent", "performerType", element.getPerformerType().get(i), i); 8737 } 8738 if (element.hasPerformerRole()) { 8739 composeCodeableConcept(t, "ActionComponent", "performerRole", element.getPerformerRole(), -1); 8740 } 8741 if (element.hasPerformer()) { 8742 composeReference(t, "ActionComponent", "performer", element.getPerformer(), -1); 8743 } 8744 for (int i = 0; i < element.getPerformerLinkId().size(); i++) { 8745 composeString(t, "ActionComponent", "performerLinkId", element.getPerformerLinkId().get(i), i); 8746 } 8747 for (int i = 0; i < element.getReason().size(); i++) { 8748 composeCodeableReference(t, "ActionComponent", "reason", element.getReason().get(i), i); 8749 } 8750 for (int i = 0; i < element.getReasonLinkId().size(); i++) { 8751 composeString(t, "ActionComponent", "reasonLinkId", element.getReasonLinkId().get(i), i); 8752 } 8753 for (int i = 0; i < element.getNote().size(); i++) { 8754 composeAnnotation(t, "ActionComponent", "note", element.getNote().get(i), i); 8755 } 8756 for (int i = 0; i < element.getSecurityLabelNumber().size(); i++) { 8757 composeUnsignedInt(t, "ActionComponent", "securityLabelNumber", element.getSecurityLabelNumber().get(i), i); 8758 } 8759 } 8760 8761 protected void composeContractActionSubjectComponent(Complex parent, String parentType, String name, Contract.ActionSubjectComponent element, int index) { 8762 if (element == null) 8763 return; 8764 Complex t; 8765 if (Utilities.noString(parentType)) 8766 t = parent; 8767 else { 8768 t = parent.predicate("fhir:"+name,index > -1); 8769 } 8770 composeBackboneElement(t, "subject", name, element, index); 8771 for (int i = 0; i < element.getReference().size(); i++) { 8772 composeReference(t, "ActionSubjectComponent", "reference", element.getReference().get(i), i); 8773 } 8774 if (element.hasRole()) { 8775 composeCodeableConcept(t, "ActionSubjectComponent", "role", element.getRole(), -1); 8776 } 8777 } 8778 8779 protected void composeContractSignatoryComponent(Complex parent, String parentType, String name, Contract.SignatoryComponent element, int index) { 8780 if (element == null) 8781 return; 8782 Complex t; 8783 if (Utilities.noString(parentType)) 8784 t = parent; 8785 else { 8786 t = parent.predicate("fhir:"+name,index > -1); 8787 } 8788 composeBackboneElement(t, "signer", name, element, index); 8789 if (element.hasType()) { 8790 composeCoding(t, "SignatoryComponent", "type", element.getType(), -1); 8791 } 8792 if (element.hasParty()) { 8793 composeReference(t, "SignatoryComponent", "party", element.getParty(), -1); 8794 } 8795 for (int i = 0; i < element.getSignature().size(); i++) { 8796 composeSignature(t, "SignatoryComponent", "signature", element.getSignature().get(i), i); 8797 } 8798 } 8799 8800 protected void composeContractFriendlyLanguageComponent(Complex parent, String parentType, String name, Contract.FriendlyLanguageComponent element, int index) { 8801 if (element == null) 8802 return; 8803 Complex t; 8804 if (Utilities.noString(parentType)) 8805 t = parent; 8806 else { 8807 t = parent.predicate("fhir:"+name,index > -1); 8808 } 8809 composeBackboneElement(t, "friendly", name, element, index); 8810 if (element.hasContent()) { 8811 composeType(t, "FriendlyLanguageComponent", "content", element.getContent(), -1); 8812 } 8813 } 8814 8815 protected void composeContractLegalLanguageComponent(Complex parent, String parentType, String name, Contract.LegalLanguageComponent element, int index) { 8816 if (element == null) 8817 return; 8818 Complex t; 8819 if (Utilities.noString(parentType)) 8820 t = parent; 8821 else { 8822 t = parent.predicate("fhir:"+name,index > -1); 8823 } 8824 composeBackboneElement(t, "legal", name, element, index); 8825 if (element.hasContent()) { 8826 composeType(t, "LegalLanguageComponent", "content", element.getContent(), -1); 8827 } 8828 } 8829 8830 protected void composeContractComputableLanguageComponent(Complex parent, String parentType, String name, Contract.ComputableLanguageComponent element, int index) { 8831 if (element == null) 8832 return; 8833 Complex t; 8834 if (Utilities.noString(parentType)) 8835 t = parent; 8836 else { 8837 t = parent.predicate("fhir:"+name,index > -1); 8838 } 8839 composeBackboneElement(t, "rule", name, element, index); 8840 if (element.hasContent()) { 8841 composeType(t, "ComputableLanguageComponent", "content", element.getContent(), -1); 8842 } 8843 } 8844 8845 protected void composeCoverage(Complex parent, String parentType, String name, Coverage element, int index) { 8846 if (element == null) 8847 return; 8848 Complex t; 8849 if (Utilities.noString(parentType)) 8850 t = parent; 8851 else { 8852 t = parent.predicate("fhir:"+name,index > -1); 8853 } 8854 composeDomainResource(t, "Coverage", name, element, index); 8855 for (int i = 0; i < element.getIdentifier().size(); i++) { 8856 composeIdentifier(t, "Coverage", "identifier", element.getIdentifier().get(i), i); 8857 } 8858 if (element.hasStatusElement()) { 8859 composeEnum(t, "Coverage", "status", element.getStatusElement(), -1); 8860 } 8861 if (element.hasKindElement()) { 8862 composeEnum(t, "Coverage", "kind", element.getKindElement(), -1); 8863 } 8864 for (int i = 0; i < element.getPaymentBy().size(); i++) { 8865 composeCoveragePaymentByComponent(t, "Coverage", "paymentBy", element.getPaymentBy().get(i), i); 8866 } 8867 if (element.hasType()) { 8868 composeCodeableConcept(t, "Coverage", "type", element.getType(), -1); 8869 } 8870 if (element.hasPolicyHolder()) { 8871 composeReference(t, "Coverage", "policyHolder", element.getPolicyHolder(), -1); 8872 } 8873 if (element.hasSubscriber()) { 8874 composeReference(t, "Coverage", "subscriber", element.getSubscriber(), -1); 8875 } 8876 for (int i = 0; i < element.getSubscriberId().size(); i++) { 8877 composeIdentifier(t, "Coverage", "subscriberId", element.getSubscriberId().get(i), i); 8878 } 8879 if (element.hasBeneficiary()) { 8880 composeReference(t, "Coverage", "beneficiary", element.getBeneficiary(), -1); 8881 } 8882 if (element.hasDependentElement()) { 8883 composeString(t, "Coverage", "dependent", element.getDependentElement(), -1); 8884 } 8885 if (element.hasRelationship()) { 8886 composeCodeableConcept(t, "Coverage", "relationship", element.getRelationship(), -1); 8887 } 8888 if (element.hasPeriod()) { 8889 composePeriod(t, "Coverage", "period", element.getPeriod(), -1); 8890 } 8891 if (element.hasInsurer()) { 8892 composeReference(t, "Coverage", "insurer", element.getInsurer(), -1); 8893 } 8894 for (int i = 0; i < element.getClass_().size(); i++) { 8895 composeCoverageClassComponent(t, "Coverage", "class", element.getClass_().get(i), i); 8896 } 8897 if (element.hasOrderElement()) { 8898 composePositiveInt(t, "Coverage", "order", element.getOrderElement(), -1); 8899 } 8900 if (element.hasNetworkElement()) { 8901 composeString(t, "Coverage", "network", element.getNetworkElement(), -1); 8902 } 8903 for (int i = 0; i < element.getCostToBeneficiary().size(); i++) { 8904 composeCoverageCostToBeneficiaryComponent(t, "Coverage", "costToBeneficiary", element.getCostToBeneficiary().get(i), i); 8905 } 8906 if (element.hasSubrogationElement()) { 8907 composeBoolean(t, "Coverage", "subrogation", element.getSubrogationElement(), -1); 8908 } 8909 for (int i = 0; i < element.getContract().size(); i++) { 8910 composeReference(t, "Coverage", "contract", element.getContract().get(i), i); 8911 } 8912 if (element.hasInsurancePlan()) { 8913 composeReference(t, "Coverage", "insurancePlan", element.getInsurancePlan(), -1); 8914 } 8915 } 8916 8917 protected void composeCoveragePaymentByComponent(Complex parent, String parentType, String name, Coverage.CoveragePaymentByComponent element, int index) { 8918 if (element == null) 8919 return; 8920 Complex t; 8921 if (Utilities.noString(parentType)) 8922 t = parent; 8923 else { 8924 t = parent.predicate("fhir:"+name,index > -1); 8925 } 8926 composeBackboneElement(t, "paymentBy", name, element, index); 8927 if (element.hasParty()) { 8928 composeReference(t, "CoveragePaymentByComponent", "party", element.getParty(), -1); 8929 } 8930 if (element.hasResponsibilityElement()) { 8931 composeString(t, "CoveragePaymentByComponent", "responsibility", element.getResponsibilityElement(), -1); 8932 } 8933 } 8934 8935 protected void composeCoverageClassComponent(Complex parent, String parentType, String name, Coverage.ClassComponent element, int index) { 8936 if (element == null) 8937 return; 8938 Complex t; 8939 if (Utilities.noString(parentType)) 8940 t = parent; 8941 else { 8942 t = parent.predicate("fhir:"+name,index > -1); 8943 } 8944 composeBackboneElement(t, "class", name, element, index); 8945 if (element.hasType()) { 8946 composeCodeableConcept(t, "ClassComponent", "type", element.getType(), -1); 8947 } 8948 if (element.hasValue()) { 8949 composeIdentifier(t, "ClassComponent", "value", element.getValue(), -1); 8950 } 8951 if (element.hasNameElement()) { 8952 composeString(t, "ClassComponent", "name", element.getNameElement(), -1); 8953 } 8954 } 8955 8956 protected void composeCoverageCostToBeneficiaryComponent(Complex parent, String parentType, String name, Coverage.CostToBeneficiaryComponent element, int index) { 8957 if (element == null) 8958 return; 8959 Complex t; 8960 if (Utilities.noString(parentType)) 8961 t = parent; 8962 else { 8963 t = parent.predicate("fhir:"+name,index > -1); 8964 } 8965 composeBackboneElement(t, "costToBeneficiary", name, element, index); 8966 if (element.hasType()) { 8967 composeCodeableConcept(t, "CostToBeneficiaryComponent", "type", element.getType(), -1); 8968 } 8969 if (element.hasCategory()) { 8970 composeCodeableConcept(t, "CostToBeneficiaryComponent", "category", element.getCategory(), -1); 8971 } 8972 if (element.hasNetwork()) { 8973 composeCodeableConcept(t, "CostToBeneficiaryComponent", "network", element.getNetwork(), -1); 8974 } 8975 if (element.hasUnit()) { 8976 composeCodeableConcept(t, "CostToBeneficiaryComponent", "unit", element.getUnit(), -1); 8977 } 8978 if (element.hasTerm()) { 8979 composeCodeableConcept(t, "CostToBeneficiaryComponent", "term", element.getTerm(), -1); 8980 } 8981 if (element.hasValue()) { 8982 composeType(t, "CostToBeneficiaryComponent", "value", element.getValue(), -1); 8983 } 8984 for (int i = 0; i < element.getException().size(); i++) { 8985 composeCoverageExemptionComponent(t, "CostToBeneficiaryComponent", "exception", element.getException().get(i), i); 8986 } 8987 } 8988 8989 protected void composeCoverageExemptionComponent(Complex parent, String parentType, String name, Coverage.ExemptionComponent element, int index) { 8990 if (element == null) 8991 return; 8992 Complex t; 8993 if (Utilities.noString(parentType)) 8994 t = parent; 8995 else { 8996 t = parent.predicate("fhir:"+name,index > -1); 8997 } 8998 composeBackboneElement(t, "exception", name, element, index); 8999 if (element.hasType()) { 9000 composeCodeableConcept(t, "ExemptionComponent", "type", element.getType(), -1); 9001 } 9002 if (element.hasPeriod()) { 9003 composePeriod(t, "ExemptionComponent", "period", element.getPeriod(), -1); 9004 } 9005 } 9006 9007 protected void composeCoverageEligibilityRequest(Complex parent, String parentType, String name, CoverageEligibilityRequest element, int index) { 9008 if (element == null) 9009 return; 9010 Complex t; 9011 if (Utilities.noString(parentType)) 9012 t = parent; 9013 else { 9014 t = parent.predicate("fhir:"+name,index > -1); 9015 } 9016 composeDomainResource(t, "CoverageEligibilityRequest", name, element, index); 9017 for (int i = 0; i < element.getIdentifier().size(); i++) { 9018 composeIdentifier(t, "CoverageEligibilityRequest", "identifier", element.getIdentifier().get(i), i); 9019 } 9020 if (element.hasStatusElement()) { 9021 composeEnum(t, "CoverageEligibilityRequest", "status", element.getStatusElement(), -1); 9022 } 9023 if (element.hasPriority()) { 9024 composeCodeableConcept(t, "CoverageEligibilityRequest", "priority", element.getPriority(), -1); 9025 } 9026 for (int i = 0; i < element.getPurpose().size(); i++) { 9027 composeEnum(t, "CoverageEligibilityRequest", "purpose", element.getPurpose().get(i), i); 9028 } 9029 if (element.hasPatient()) { 9030 composeReference(t, "CoverageEligibilityRequest", "patient", element.getPatient(), -1); 9031 } 9032 for (int i = 0; i < element.getEvent().size(); i++) { 9033 composeCoverageEligibilityRequestEventComponent(t, "CoverageEligibilityRequest", "event", element.getEvent().get(i), i); 9034 } 9035 if (element.hasServiced()) { 9036 composeType(t, "CoverageEligibilityRequest", "serviced", element.getServiced(), -1); 9037 } 9038 if (element.hasCreatedElement()) { 9039 composeDateTime(t, "CoverageEligibilityRequest", "created", element.getCreatedElement(), -1); 9040 } 9041 if (element.hasEnterer()) { 9042 composeReference(t, "CoverageEligibilityRequest", "enterer", element.getEnterer(), -1); 9043 } 9044 if (element.hasProvider()) { 9045 composeReference(t, "CoverageEligibilityRequest", "provider", element.getProvider(), -1); 9046 } 9047 if (element.hasInsurer()) { 9048 composeReference(t, "CoverageEligibilityRequest", "insurer", element.getInsurer(), -1); 9049 } 9050 if (element.hasFacility()) { 9051 composeReference(t, "CoverageEligibilityRequest", "facility", element.getFacility(), -1); 9052 } 9053 for (int i = 0; i < element.getSupportingInfo().size(); i++) { 9054 composeCoverageEligibilityRequestSupportingInformationComponent(t, "CoverageEligibilityRequest", "supportingInfo", element.getSupportingInfo().get(i), i); 9055 } 9056 for (int i = 0; i < element.getInsurance().size(); i++) { 9057 composeCoverageEligibilityRequestInsuranceComponent(t, "CoverageEligibilityRequest", "insurance", element.getInsurance().get(i), i); 9058 } 9059 for (int i = 0; i < element.getItem().size(); i++) { 9060 composeCoverageEligibilityRequestDetailsComponent(t, "CoverageEligibilityRequest", "item", element.getItem().get(i), i); 9061 } 9062 } 9063 9064 protected void composeCoverageEligibilityRequestEventComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.CoverageEligibilityRequestEventComponent element, int index) { 9065 if (element == null) 9066 return; 9067 Complex t; 9068 if (Utilities.noString(parentType)) 9069 t = parent; 9070 else { 9071 t = parent.predicate("fhir:"+name,index > -1); 9072 } 9073 composeBackboneElement(t, "event", name, element, index); 9074 if (element.hasType()) { 9075 composeCodeableConcept(t, "CoverageEligibilityRequestEventComponent", "type", element.getType(), -1); 9076 } 9077 if (element.hasWhen()) { 9078 composeType(t, "CoverageEligibilityRequestEventComponent", "when", element.getWhen(), -1); 9079 } 9080 } 9081 9082 protected void composeCoverageEligibilityRequestSupportingInformationComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.SupportingInformationComponent element, int index) { 9083 if (element == null) 9084 return; 9085 Complex t; 9086 if (Utilities.noString(parentType)) 9087 t = parent; 9088 else { 9089 t = parent.predicate("fhir:"+name,index > -1); 9090 } 9091 composeBackboneElement(t, "supportingInfo", name, element, index); 9092 if (element.hasSequenceElement()) { 9093 composePositiveInt(t, "SupportingInformationComponent", "sequence", element.getSequenceElement(), -1); 9094 } 9095 if (element.hasInformation()) { 9096 composeReference(t, "SupportingInformationComponent", "information", element.getInformation(), -1); 9097 } 9098 if (element.hasAppliesToAllElement()) { 9099 composeBoolean(t, "SupportingInformationComponent", "appliesToAll", element.getAppliesToAllElement(), -1); 9100 } 9101 } 9102 9103 protected void composeCoverageEligibilityRequestInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.InsuranceComponent element, int index) { 9104 if (element == null) 9105 return; 9106 Complex t; 9107 if (Utilities.noString(parentType)) 9108 t = parent; 9109 else { 9110 t = parent.predicate("fhir:"+name,index > -1); 9111 } 9112 composeBackboneElement(t, "insurance", name, element, index); 9113 if (element.hasFocalElement()) { 9114 composeBoolean(t, "InsuranceComponent", "focal", element.getFocalElement(), -1); 9115 } 9116 if (element.hasCoverage()) { 9117 composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1); 9118 } 9119 if (element.hasBusinessArrangementElement()) { 9120 composeString(t, "InsuranceComponent", "businessArrangement", element.getBusinessArrangementElement(), -1); 9121 } 9122 } 9123 9124 protected void composeCoverageEligibilityRequestDetailsComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DetailsComponent element, int index) { 9125 if (element == null) 9126 return; 9127 Complex t; 9128 if (Utilities.noString(parentType)) 9129 t = parent; 9130 else { 9131 t = parent.predicate("fhir:"+name,index > -1); 9132 } 9133 composeBackboneElement(t, "item", name, element, index); 9134 for (int i = 0; i < element.getSupportingInfoSequence().size(); i++) { 9135 composePositiveInt(t, "DetailsComponent", "supportingInfoSequence", element.getSupportingInfoSequence().get(i), i); 9136 } 9137 if (element.hasCategory()) { 9138 composeCodeableConcept(t, "DetailsComponent", "category", element.getCategory(), -1); 9139 } 9140 if (element.hasProductOrService()) { 9141 composeCodeableConcept(t, "DetailsComponent", "productOrService", element.getProductOrService(), -1); 9142 } 9143 for (int i = 0; i < element.getModifier().size(); i++) { 9144 composeCodeableConcept(t, "DetailsComponent", "modifier", element.getModifier().get(i), i); 9145 } 9146 if (element.hasProvider()) { 9147 composeReference(t, "DetailsComponent", "provider", element.getProvider(), -1); 9148 } 9149 if (element.hasQuantity()) { 9150 composeQuantity(t, "DetailsComponent", "quantity", element.getQuantity(), -1); 9151 } 9152 if (element.hasUnitPrice()) { 9153 composeMoney(t, "DetailsComponent", "unitPrice", element.getUnitPrice(), -1); 9154 } 9155 if (element.hasFacility()) { 9156 composeReference(t, "DetailsComponent", "facility", element.getFacility(), -1); 9157 } 9158 for (int i = 0; i < element.getDiagnosis().size(); i++) { 9159 composeCoverageEligibilityRequestDiagnosisComponent(t, "DetailsComponent", "diagnosis", element.getDiagnosis().get(i), i); 9160 } 9161 for (int i = 0; i < element.getDetail().size(); i++) { 9162 composeReference(t, "DetailsComponent", "detail", element.getDetail().get(i), i); 9163 } 9164 } 9165 9166 protected void composeCoverageEligibilityRequestDiagnosisComponent(Complex parent, String parentType, String name, CoverageEligibilityRequest.DiagnosisComponent element, int index) { 9167 if (element == null) 9168 return; 9169 Complex t; 9170 if (Utilities.noString(parentType)) 9171 t = parent; 9172 else { 9173 t = parent.predicate("fhir:"+name,index > -1); 9174 } 9175 composeBackboneElement(t, "diagnosis", name, element, index); 9176 if (element.hasDiagnosis()) { 9177 composeType(t, "DiagnosisComponent", "diagnosis", element.getDiagnosis(), -1); 9178 } 9179 } 9180 9181 protected void composeCoverageEligibilityResponse(Complex parent, String parentType, String name, CoverageEligibilityResponse element, int index) { 9182 if (element == null) 9183 return; 9184 Complex t; 9185 if (Utilities.noString(parentType)) 9186 t = parent; 9187 else { 9188 t = parent.predicate("fhir:"+name,index > -1); 9189 } 9190 composeDomainResource(t, "CoverageEligibilityResponse", name, element, index); 9191 for (int i = 0; i < element.getIdentifier().size(); i++) { 9192 composeIdentifier(t, "CoverageEligibilityResponse", "identifier", element.getIdentifier().get(i), i); 9193 } 9194 if (element.hasStatusElement()) { 9195 composeEnum(t, "CoverageEligibilityResponse", "status", element.getStatusElement(), -1); 9196 } 9197 for (int i = 0; i < element.getPurpose().size(); i++) { 9198 composeEnum(t, "CoverageEligibilityResponse", "purpose", element.getPurpose().get(i), i); 9199 } 9200 if (element.hasPatient()) { 9201 composeReference(t, "CoverageEligibilityResponse", "patient", element.getPatient(), -1); 9202 } 9203 for (int i = 0; i < element.getEvent().size(); i++) { 9204 composeCoverageEligibilityResponseEventComponent(t, "CoverageEligibilityResponse", "event", element.getEvent().get(i), i); 9205 } 9206 if (element.hasServiced()) { 9207 composeType(t, "CoverageEligibilityResponse", "serviced", element.getServiced(), -1); 9208 } 9209 if (element.hasCreatedElement()) { 9210 composeDateTime(t, "CoverageEligibilityResponse", "created", element.getCreatedElement(), -1); 9211 } 9212 if (element.hasRequestor()) { 9213 composeReference(t, "CoverageEligibilityResponse", "requestor", element.getRequestor(), -1); 9214 } 9215 if (element.hasRequest()) { 9216 composeReference(t, "CoverageEligibilityResponse", "request", element.getRequest(), -1); 9217 } 9218 if (element.hasOutcomeElement()) { 9219 composeEnum(t, "CoverageEligibilityResponse", "outcome", element.getOutcomeElement(), -1); 9220 } 9221 if (element.hasDispositionElement()) { 9222 composeString(t, "CoverageEligibilityResponse", "disposition", element.getDispositionElement(), -1); 9223 } 9224 if (element.hasInsurer()) { 9225 composeReference(t, "CoverageEligibilityResponse", "insurer", element.getInsurer(), -1); 9226 } 9227 for (int i = 0; i < element.getInsurance().size(); i++) { 9228 composeCoverageEligibilityResponseInsuranceComponent(t, "CoverageEligibilityResponse", "insurance", element.getInsurance().get(i), i); 9229 } 9230 if (element.hasPreAuthRefElement()) { 9231 composeString(t, "CoverageEligibilityResponse", "preAuthRef", element.getPreAuthRefElement(), -1); 9232 } 9233 if (element.hasForm()) { 9234 composeCodeableConcept(t, "CoverageEligibilityResponse", "form", element.getForm(), -1); 9235 } 9236 for (int i = 0; i < element.getError().size(); i++) { 9237 composeCoverageEligibilityResponseErrorsComponent(t, "CoverageEligibilityResponse", "error", element.getError().get(i), i); 9238 } 9239 } 9240 9241 protected void composeCoverageEligibilityResponseEventComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.CoverageEligibilityResponseEventComponent element, int index) { 9242 if (element == null) 9243 return; 9244 Complex t; 9245 if (Utilities.noString(parentType)) 9246 t = parent; 9247 else { 9248 t = parent.predicate("fhir:"+name,index > -1); 9249 } 9250 composeBackboneElement(t, "event", name, element, index); 9251 if (element.hasType()) { 9252 composeCodeableConcept(t, "CoverageEligibilityResponseEventComponent", "type", element.getType(), -1); 9253 } 9254 if (element.hasWhen()) { 9255 composeType(t, "CoverageEligibilityResponseEventComponent", "when", element.getWhen(), -1); 9256 } 9257 } 9258 9259 protected void composeCoverageEligibilityResponseInsuranceComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.InsuranceComponent element, int index) { 9260 if (element == null) 9261 return; 9262 Complex t; 9263 if (Utilities.noString(parentType)) 9264 t = parent; 9265 else { 9266 t = parent.predicate("fhir:"+name,index > -1); 9267 } 9268 composeBackboneElement(t, "insurance", name, element, index); 9269 if (element.hasCoverage()) { 9270 composeReference(t, "InsuranceComponent", "coverage", element.getCoverage(), -1); 9271 } 9272 if (element.hasInforceElement()) { 9273 composeBoolean(t, "InsuranceComponent", "inforce", element.getInforceElement(), -1); 9274 } 9275 if (element.hasBenefitPeriod()) { 9276 composePeriod(t, "InsuranceComponent", "benefitPeriod", element.getBenefitPeriod(), -1); 9277 } 9278 for (int i = 0; i < element.getItem().size(); i++) { 9279 composeCoverageEligibilityResponseItemsComponent(t, "InsuranceComponent", "item", element.getItem().get(i), i); 9280 } 9281 } 9282 9283 protected void composeCoverageEligibilityResponseItemsComponent(Complex parent, String parentType, String name, CoverageEligibilityResponse.ItemsComponent element, int index) { 9284 if (element == null) 9285 return; 9286 Complex t; 9287 if (Utilities.noString(parentType)) 9288 t = parent; 9289 else { 9290 t = parent.predicate("fhir:"+name,index > -1); 9291 } 9292 composeBackboneElement(t, "item", name, element, index); 9293 if (element.hasCategory()) { 9294 composeCodeableConcept(t, "ItemsComponent", "category", element.getCategory(), -1); 9295 } 9296 if (element.hasProductOrService()) { 9297 composeCodeableConcept(t, "ItemsComponent", "productOrService", element.getProductOrService(), -1); 9298 } 9299 for (int i = 0; i < element.getModifier().size(); i++) { 9300 composeCodeableConcept(t, "ItemsComponent", "modifier", element.getModifier().get(i), i); 9301 } 9302 if (element.hasProvider()) { 9303 composeReference(t, "ItemsComponent", "provider", element.getProvider(), -1); 9304 } 9305 if (element.hasExcludedElement()) { 9306 composeBoolean(t, "ItemsComponent", "excluded", element.getExcludedElement(), -1); 9307 } 9308 if (element.hasNameElement()) { 9309 composeString(t, "ItemsComponent", "name", element.getNameElement(), -1); 9310 } 9311 if (element.hasDescriptionElement()) { 9312 composeString(t, "ItemsComponent", "description", element.getDescriptionElement(), -1); 9313 } 9314 if (element.hasNetwork()) { 9315 composeCodeableConcept(t, "ItemsComponent", "network", element.getNetwork(), -1); 9316 } 9317 if (element.hasUnit()) { 9318 composeCodeableConcept(t, "ItemsComponent", "unit", element.getUnit(), -1); 9319 } 9320 if (element.hasTerm()) { 9321 composeCodeableConcept(t, "ItemsComponent", "term",