001package org.hl7.fhir.dstu3.formats; 002 003/*- 004 * #%L 005 * org.hl7.fhir.dstu3 006 * %% 007 * Copyright (C) 2014 - 2019 Health Level 7 008 * %% 009 * Licensed under the Apache License, Version 2.0 (the "License"); 010 * you may not use this file except in compliance with the License. 011 * You may obtain a copy of the License at 012 * 013 * http://www.apache.org/licenses/LICENSE-2.0 014 * 015 * Unless required by applicable law or agreed to in writing, software 016 * distributed under the License is distributed on an "AS IS" BASIS, 017 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 018 * See the License for the specific language governing permissions and 019 * limitations under the License. 020 * #L% 021 */ 022 023 024/* 025 Copyright (c) 2011+, HL7, Inc. 026 All rights reserved. 027 028 Redistribution and use in source and binary forms, with or without modification, 029 are permitted provided that the following conditions are met: 030 031 * Redistributions of source code must retain the above copyright notice, this 032 list of conditions and the following disclaimer. 033 * Redistributions in binary form must reproduce the above copyright notice, 034 this list of conditions and the following disclaimer in the documentation 035 and/or other materials provided with the distribution. 036 * Neither the name of HL7 nor the names of its contributors may be used to 037 endorse or promote products derived from this software without specific 038 prior written permission. 039 040 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 041 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 042 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 043 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 044 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 045 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 046 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 047 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 048 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 049 POSSIBILITY OF SUCH DAMAGE. 050 051*/ 052 053// Generated on Mon, Apr 17, 2017 08:38+1000 for FHIR v3.0.x 054import org.hl7.fhir.dstu3.model.*; 055import org.hl7.fhir.dstu3.utils.formats.Turtle.Complex; 056import org.hl7.fhir.utilities.Utilities; 057 058public class RdfParser extends RdfParserBase { 059 060 public RdfParser() { 061 super(); 062 } 063 064 public RdfParser(boolean allowUnknownContent) { 065 super(); 066 setAllowUnknownContent(allowUnknownContent); 067 } 068 069 070 protected void composeElement(Complex t, String parentType, String name, Element element, int index) { 071 if (element == null) 072 return; 073 if (index > -1) 074 t.predicate("fhir:index", Integer.toString(index)); 075 if (element.hasIdElement()) 076 composeString(t, "Element", "id", element.getIdElement(), -1); 077 for (int i = 0; i < element.getExtension().size(); i++) 078 composeExtension(t, "Element", "extension", element.getExtension().get(i), i); 079 } 080 081 protected void composeBackboneElement(Complex t, String tType, String name, BackboneElement element, int index) { 082 composeElement(t, tType, name, element, index); 083 for (int i = 0; i < element.getModifierExtension().size(); i++) 084 composeExtension(t, "Element", "modifierExtension", element.getModifierExtension().get(i), i); 085 } 086 087 private void composeEnum(Complex parent, String parentType, String name, Enumeration<? extends Enum> value, int index) { 088 if (value == null) 089 return; 090 Complex t = parent.predicate("fhir:"+parentType+"."+name); 091 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 092 composeElement(t, parentType, name, value, index); 093 decorateCode(t, value); 094 } 095 096 097 protected void composeDate(Complex parent, String parentType, String name, DateType value, int index) { 098 if (value == null) 099 return; 100 Complex t = parent.predicate("fhir:"+parentType+"."+name); 101 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 102 composeElement(t, parentType, name, value, index); 103 } 104 105 protected void composeDateTime(Complex parent, String parentType, String name, DateTimeType value, int index) { 106 if (value == null) 107 return; 108 Complex t = parent.predicate("fhir:"+parentType+"."+name); 109 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 110 composeElement(t, parentType, name, value, index); 111 } 112 113 protected void composeCode(Complex parent, String parentType, String name, CodeType value, int index) { 114 if (value == null) 115 return; 116 Complex t = parent.predicate("fhir:"+parentType+"."+name); 117 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 118 composeElement(t, parentType, name, value, index); 119 decorateCode(t, value); 120 } 121 122 protected void composeString(Complex parent, String parentType, String name, StringType value, int index) { 123 if (value == null) 124 return; 125 Complex t = parent.predicate("fhir:"+parentType+"."+name); 126 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 127 composeElement(t, parentType, name, value, index); 128 } 129 130 protected void composeInteger(Complex parent, String parentType, String name, IntegerType value, int index) { 131 if (value == null) 132 return; 133 Complex t = parent.predicate("fhir:"+parentType+"."+name); 134 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 135 composeElement(t, parentType, name, value, index); 136 } 137 138 protected void composeOid(Complex parent, String parentType, String name, OidType value, int index) { 139 if (value == null) 140 return; 141 Complex t = parent.predicate("fhir:"+parentType+"."+name); 142 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 143 composeElement(t, parentType, name, value, index); 144 } 145 146 protected void composeUri(Complex parent, String parentType, String name, UriType value, int index) { 147 if (value == null) 148 return; 149 Complex t = parent.predicate("fhir:"+parentType+"."+name); 150 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 151 composeElement(t, parentType, name, value, index); 152 } 153 154 protected void composeUuid(Complex parent, String parentType, String name, UuidType value, int index) { 155 if (value == null) 156 return; 157 Complex t = parent.predicate("fhir:"+parentType+"."+name); 158 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 159 composeElement(t, parentType, name, value, index); 160 } 161 162 protected void composeInstant(Complex parent, String parentType, String name, InstantType value, int index) { 163 if (value == null) 164 return; 165 Complex t = parent.predicate("fhir:"+parentType+"."+name); 166 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 167 composeElement(t, parentType, name, value, index); 168 } 169 170 protected void composeBoolean(Complex parent, String parentType, String name, BooleanType value, int index) { 171 if (value == null) 172 return; 173 Complex t = parent.predicate("fhir:"+parentType+"."+name); 174 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 175 composeElement(t, parentType, name, value, index); 176 } 177 178 protected void composeBase64Binary(Complex parent, String parentType, String name, Base64BinaryType value, int index) { 179 if (value == null) 180 return; 181 Complex t = parent.predicate("fhir:"+parentType+"."+name); 182 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 183 composeElement(t, parentType, name, value, index); 184 } 185 186 protected void composeUnsignedInt(Complex parent, String parentType, String name, UnsignedIntType value, int index) { 187 if (value == null) 188 return; 189 Complex t = parent.predicate("fhir:"+parentType+"."+name); 190 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 191 composeElement(t, parentType, name, value, index); 192 } 193 194 protected void composeMarkdown(Complex parent, String parentType, String name, MarkdownType value, int index) { 195 if (value == null) 196 return; 197 Complex t = parent.predicate("fhir:"+parentType+"."+name); 198 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 199 composeElement(t, parentType, name, value, index); 200 } 201 202 protected void composeTime(Complex parent, String parentType, String name, TimeType value, int index) { 203 if (value == null) 204 return; 205 Complex t = parent.predicate("fhir:"+parentType+"."+name); 206 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 207 composeElement(t, parentType, name, value, index); 208 } 209 210 protected void composeId(Complex parent, String parentType, String name, IdType value, int index) { 211 if (value == null) 212 return; 213 Complex t = parent.predicate("fhir:"+parentType+"."+name); 214 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 215 composeElement(t, parentType, name, value, index); 216 } 217 218 protected void composePositiveInt(Complex parent, String parentType, String name, PositiveIntType value, int index) { 219 if (value == null) 220 return; 221 Complex t = parent.predicate("fhir:"+parentType+"."+name); 222 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 223 composeElement(t, parentType, name, value, index); 224 } 225 226 protected void composeDecimal(Complex parent, String parentType, String name, DecimalType value, int index) { 227 if (value == null) 228 return; 229 Complex t = parent.predicate("fhir:"+parentType+"."+name); 230 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 231 composeElement(t, parentType, name, value, index); 232 } 233 234 protected void composeExtension(Complex parent, String parentType, String name, Extension element, int index) { 235 if (element == null) 236 return; 237 Complex t; 238 if (Utilities.noString(parentType)) 239 t = parent; 240 else { 241 t = parent.predicate("fhir:"+parentType+'.'+name); 242 } 243 composeElement(t, "Extension", name, element, index); 244 if (element.hasUrlElement()) 245 composeUri(t, "Extension", "url", element.getUrlElement(), -1); 246 if (element.hasValue()) 247 composeType(t, "Extension", "value", element.getValue(), -1); 248 } 249 250 protected void composeNarrative(Complex parent, String parentType, String name, Narrative element, int index) { 251 if (element == null) 252 return; 253 Complex t; 254 if (Utilities.noString(parentType)) 255 t = parent; 256 else { 257 t = parent.predicate("fhir:"+parentType+'.'+name); 258 } 259 composeElement(t, "Narrative", name, element, index); 260 if (element.hasStatusElement()) 261 composeEnum(t, "Narrative", "status", element.getStatusElement(), -1); 262 if (element.hasDiv()) 263 composeXhtml(t, "Narrative", "div", element.getDiv(), -1); 264 } 265 266 protected void composeReference(Complex parent, String parentType, String name, Reference element, int index) { 267 if (element == null) 268 return; 269 Complex t; 270 if (Utilities.noString(parentType)) 271 t = parent; 272 else { 273 t = parent.predicate("fhir:"+parentType+'.'+name); 274 } 275 composeElement(t, "Reference", name, element, index); 276 if (element.hasReferenceElement()) 277 composeString(t, "Reference", "reference", element.getReferenceElement_(), -1); 278 if (element.hasIdentifier()) 279 composeIdentifier(t, "Reference", "identifier", element.getIdentifier(), -1); 280 if (element.hasDisplayElement()) 281 composeString(t, "Reference", "display", element.getDisplayElement(), -1); 282 } 283 284 protected void composeQuantity(Complex parent, String parentType, String name, Quantity element, int index) { 285 if (element == null) 286 return; 287 Complex t; 288 if (Utilities.noString(parentType)) 289 t = parent; 290 else { 291 t = parent.predicate("fhir:"+parentType+'.'+name); 292 } 293 composeElement(t, "Quantity", name, element, index); 294 if (element.hasValueElement()) 295 composeDecimal(t, "Quantity", "value", element.getValueElement(), -1); 296 if (element.hasComparatorElement()) 297 composeEnum(t, "Quantity", "comparator", element.getComparatorElement(), -1); 298 if (element.hasUnitElement()) 299 composeString(t, "Quantity", "unit", element.getUnitElement(), -1); 300 if (element.hasSystemElement()) 301 composeUri(t, "Quantity", "system", element.getSystemElement(), -1); 302 if (element.hasCodeElement()) 303 composeCode(t, "Quantity", "code", element.getCodeElement(), -1); 304 } 305 306 protected void composePeriod(Complex parent, String parentType, String name, Period element, int index) { 307 if (element == null) 308 return; 309 Complex t; 310 if (Utilities.noString(parentType)) 311 t = parent; 312 else { 313 t = parent.predicate("fhir:"+parentType+'.'+name); 314 } 315 composeElement(t, "Period", name, element, index); 316 if (element.hasStartElement()) 317 composeDateTime(t, "Period", "start", element.getStartElement(), -1); 318 if (element.hasEndElement()) 319 composeDateTime(t, "Period", "end", element.getEndElement(), -1); 320 } 321 322 protected void composeAttachment(Complex parent, String parentType, String name, Attachment element, int index) { 323 if (element == null) 324 return; 325 Complex t; 326 if (Utilities.noString(parentType)) 327 t = parent; 328 else { 329 t = parent.predicate("fhir:"+parentType+'.'+name); 330 } 331 composeElement(t, "Attachment", name, element, index); 332 if (element.hasContentTypeElement()) 333 composeCode(t, "Attachment", "contentType", element.getContentTypeElement(), -1); 334 if (element.hasLanguageElement()) 335 composeCode(t, "Attachment", "language", element.getLanguageElement(), -1); 336 if (element.hasDataElement()) 337 composeBase64Binary(t, "Attachment", "data", element.getDataElement(), -1); 338 if (element.hasUrlElement()) 339 composeUri(t, "Attachment", "url", element.getUrlElement(), -1); 340 if (element.hasSizeElement()) 341 composeUnsignedInt(t, "Attachment", "size", element.getSizeElement(), -1); 342 if (element.hasHashElement()) 343 composeBase64Binary(t, "Attachment", "hash", element.getHashElement(), -1); 344 if (element.hasTitleElement()) 345 composeString(t, "Attachment", "title", element.getTitleElement(), -1); 346 if (element.hasCreationElement()) 347 composeDateTime(t, "Attachment", "creation", element.getCreationElement(), -1); 348 } 349 350 protected void composeDuration(Complex parent, String parentType, String name, Duration element, int index) { 351 if (element == null) 352 return; 353 Complex t; 354 if (Utilities.noString(parentType)) 355 t = parent; 356 else { 357 t = parent.predicate("fhir:"+parentType+'.'+name); 358 } 359 composeElement(t, "Duration", name, element, index); 360 } 361 362 protected void composeCount(Complex parent, String parentType, String name, Count element, int index) { 363 if (element == null) 364 return; 365 Complex t; 366 if (Utilities.noString(parentType)) 367 t = parent; 368 else { 369 t = parent.predicate("fhir:"+parentType+'.'+name); 370 } 371 composeElement(t, "Count", name, element, index); 372 } 373 374 protected void composeRange(Complex parent, String parentType, String name, Range element, int index) { 375 if (element == null) 376 return; 377 Complex t; 378 if (Utilities.noString(parentType)) 379 t = parent; 380 else { 381 t = parent.predicate("fhir:"+parentType+'.'+name); 382 } 383 composeElement(t, "Range", name, element, index); 384 if (element.hasLow()) 385 composeQuantity(t, "Range", "low", element.getLow(), -1); 386 if (element.hasHigh()) 387 composeQuantity(t, "Range", "high", element.getHigh(), -1); 388 } 389 390 protected void composeAnnotation(Complex parent, String parentType, String name, Annotation element, int index) { 391 if (element == null) 392 return; 393 Complex t; 394 if (Utilities.noString(parentType)) 395 t = parent; 396 else { 397 t = parent.predicate("fhir:"+parentType+'.'+name); 398 } 399 composeElement(t, "Annotation", name, element, index); 400 if (element.hasAuthor()) 401 composeType(t, "Annotation", "author", element.getAuthor(), -1); 402 if (element.hasTimeElement()) 403 composeDateTime(t, "Annotation", "time", element.getTimeElement(), -1); 404 if (element.hasTextElement()) 405 composeString(t, "Annotation", "text", element.getTextElement(), -1); 406 } 407 408 protected void composeMoney(Complex parent, String parentType, String name, Money element, int index) { 409 if (element == null) 410 return; 411 Complex t; 412 if (Utilities.noString(parentType)) 413 t = parent; 414 else { 415 t = parent.predicate("fhir:"+parentType+'.'+name); 416 } 417 composeElement(t, "Money", name, element, index); 418 } 419 420 protected void composeIdentifier(Complex parent, String parentType, String name, Identifier element, int index) { 421 if (element == null) 422 return; 423 Complex t; 424 if (Utilities.noString(parentType)) 425 t = parent; 426 else { 427 t = parent.predicate("fhir:"+parentType+'.'+name); 428 } 429 composeElement(t, "Identifier", name, element, index); 430 if (element.hasUseElement()) 431 composeEnum(t, "Identifier", "use", element.getUseElement(), -1); 432 if (element.hasType()) 433 composeCodeableConcept(t, "Identifier", "type", element.getType(), -1); 434 if (element.hasSystemElement()) 435 composeUri(t, "Identifier", "system", element.getSystemElement(), -1); 436 if (element.hasValueElement()) 437 composeString(t, "Identifier", "value", element.getValueElement(), -1); 438 if (element.hasPeriod()) 439 composePeriod(t, "Identifier", "period", element.getPeriod(), -1); 440 if (element.hasAssigner()) 441 composeReference(t, "Identifier", "assigner", element.getAssigner(), -1); 442 } 443 444 protected void composeCoding(Complex parent, String parentType, String name, Coding element, int index) { 445 if (element == null) 446 return; 447 Complex t; 448 if (Utilities.noString(parentType)) 449 t = parent; 450 else { 451 t = parent.predicate("fhir:"+parentType+'.'+name); 452 } 453 composeElement(t, "Coding", name, element, index); 454 decorateCoding(t, element); 455 if (element.hasSystemElement()) 456 composeUri(t, "Coding", "system", element.getSystemElement(), -1); 457 if (element.hasVersionElement()) 458 composeString(t, "Coding", "version", element.getVersionElement(), -1); 459 if (element.hasCodeElement()) 460 composeCode(t, "Coding", "code", element.getCodeElement(), -1); 461 if (element.hasDisplayElement()) 462 composeString(t, "Coding", "display", element.getDisplayElement(), -1); 463 if (element.hasUserSelectedElement()) 464 composeBoolean(t, "Coding", "userSelected", element.getUserSelectedElement(), -1); 465 } 466 467 protected void composeSignature(Complex parent, String parentType, String name, Signature element, int index) { 468 if (element == null) 469 return; 470 Complex t; 471 if (Utilities.noString(parentType)) 472 t = parent; 473 else { 474 t = parent.predicate("fhir:"+parentType+'.'+name); 475 } 476 composeElement(t, "Signature", name, element, index); 477 for (int i = 0; i < element.getType().size(); i++) 478 composeCoding(t, "Signature", "type", element.getType().get(i), i); 479 if (element.hasWhenElement()) 480 composeInstant(t, "Signature", "when", element.getWhenElement(), -1); 481 if (element.hasWho()) 482 composeType(t, "Signature", "who", element.getWho(), -1); 483 if (element.hasOnBehalfOf()) 484 composeType(t, "Signature", "onBehalfOf", element.getOnBehalfOf(), -1); 485 if (element.hasContentTypeElement()) 486 composeCode(t, "Signature", "contentType", element.getContentTypeElement(), -1); 487 if (element.hasBlobElement()) 488 composeBase64Binary(t, "Signature", "blob", element.getBlobElement(), -1); 489 } 490 491 protected void composeSampledData(Complex parent, String parentType, String name, SampledData element, int index) { 492 if (element == null) 493 return; 494 Complex t; 495 if (Utilities.noString(parentType)) 496 t = parent; 497 else { 498 t = parent.predicate("fhir:"+parentType+'.'+name); 499 } 500 composeElement(t, "SampledData", name, element, index); 501 if (element.hasOrigin()) 502 composeQuantity(t, "SampledData", "origin", element.getOrigin(), -1); 503 if (element.hasPeriodElement()) 504 composeDecimal(t, "SampledData", "period", element.getPeriodElement(), -1); 505 if (element.hasFactorElement()) 506 composeDecimal(t, "SampledData", "factor", element.getFactorElement(), -1); 507 if (element.hasLowerLimitElement()) 508 composeDecimal(t, "SampledData", "lowerLimit", element.getLowerLimitElement(), -1); 509 if (element.hasUpperLimitElement()) 510 composeDecimal(t, "SampledData", "upperLimit", element.getUpperLimitElement(), -1); 511 if (element.hasDimensionsElement()) 512 composePositiveInt(t, "SampledData", "dimensions", element.getDimensionsElement(), -1); 513 if (element.hasDataElement()) 514 composeString(t, "SampledData", "data", element.getDataElement(), -1); 515 } 516 517 protected void composeRatio(Complex parent, String parentType, String name, Ratio element, int index) { 518 if (element == null) 519 return; 520 Complex t; 521 if (Utilities.noString(parentType)) 522 t = parent; 523 else { 524 t = parent.predicate("fhir:"+parentType+'.'+name); 525 } 526 composeElement(t, "Ratio", name, element, index); 527 if (element.hasNumerator()) 528 composeQuantity(t, "Ratio", "numerator", element.getNumerator(), -1); 529 if (element.hasDenominator()) 530 composeQuantity(t, "Ratio", "denominator", element.getDenominator(), -1); 531 } 532 533 protected void composeDistance(Complex parent, String parentType, String name, Distance element, int index) { 534 if (element == null) 535 return; 536 Complex t; 537 if (Utilities.noString(parentType)) 538 t = parent; 539 else { 540 t = parent.predicate("fhir:"+parentType+'.'+name); 541 } 542 composeElement(t, "Distance", name, element, index); 543 } 544 545 protected void composeAge(Complex parent, String parentType, String name, Age element, int index) { 546 if (element == null) 547 return; 548 Complex t; 549 if (Utilities.noString(parentType)) 550 t = parent; 551 else { 552 t = parent.predicate("fhir:"+parentType+'.'+name); 553 } 554 composeElement(t, "Age", name, element, index); 555 } 556 557 protected void composeCodeableConcept(Complex parent, String parentType, String name, CodeableConcept element, int index) { 558 if (element == null) 559 return; 560 Complex t; 561 if (Utilities.noString(parentType)) 562 t = parent; 563 else { 564 t = parent.predicate("fhir:"+parentType+'.'+name); 565 } 566 composeElement(t, "CodeableConcept", name, element, index); 567 decorateCodeableConcept(t, element); 568 for (int i = 0; i < element.getCoding().size(); i++) 569 composeCoding(t, "CodeableConcept", "coding", element.getCoding().get(i), i); 570 if (element.hasTextElement()) 571 composeString(t, "CodeableConcept", "text", element.getTextElement(), -1); 572 } 573 574 protected void composeMeta(Complex parent, String parentType, String name, Meta element, int index) { 575 if (element == null) 576 return; 577 Complex t; 578 if (Utilities.noString(parentType)) 579 t = parent; 580 else { 581 t = parent.predicate("fhir:"+parentType+'.'+name); 582 } 583 composeElement(t, "Meta", name, element, index); 584 if (element.hasVersionIdElement()) 585 composeId(t, "Meta", "versionId", element.getVersionIdElement(), -1); 586 if (element.hasLastUpdatedElement()) 587 composeInstant(t, "Meta", "lastUpdated", element.getLastUpdatedElement(), -1); 588 for (int i = 0; i < element.getProfile().size(); i++) 589 composeUri(t, "Meta", "profile", element.getProfile().get(i), i); 590 for (int i = 0; i < element.getSecurity().size(); i++) 591 composeCoding(t, "Meta", "security", element.getSecurity().get(i), i); 592 for (int i = 0; i < element.getTag().size(); i++) 593 composeCoding(t, "Meta", "tag", element.getTag().get(i), i); 594 } 595 596 protected void composeAddress(Complex parent, String parentType, String name, Address element, int index) { 597 if (element == null) 598 return; 599 Complex t; 600 if (Utilities.noString(parentType)) 601 t = parent; 602 else { 603 t = parent.predicate("fhir:"+parentType+'.'+name); 604 } 605 composeElement(t, "Address", name, element, index); 606 if (element.hasUseElement()) 607 composeEnum(t, "Address", "use", element.getUseElement(), -1); 608 if (element.hasTypeElement()) 609 composeEnum(t, "Address", "type", element.getTypeElement(), -1); 610 if (element.hasTextElement()) 611 composeString(t, "Address", "text", element.getTextElement(), -1); 612 for (int i = 0; i < element.getLine().size(); i++) 613 composeString(t, "Address", "line", element.getLine().get(i), i); 614 if (element.hasCityElement()) 615 composeString(t, "Address", "city", element.getCityElement(), -1); 616 if (element.hasDistrictElement()) 617 composeString(t, "Address", "district", element.getDistrictElement(), -1); 618 if (element.hasStateElement()) 619 composeString(t, "Address", "state", element.getStateElement(), -1); 620 if (element.hasPostalCodeElement()) 621 composeString(t, "Address", "postalCode", element.getPostalCodeElement(), -1); 622 if (element.hasCountryElement()) 623 composeString(t, "Address", "country", element.getCountryElement(), -1); 624 if (element.hasPeriod()) 625 composePeriod(t, "Address", "period", element.getPeriod(), -1); 626 } 627 628 protected void composeTriggerDefinition(Complex parent, String parentType, String name, TriggerDefinition element, int index) { 629 if (element == null) 630 return; 631 Complex t; 632 if (Utilities.noString(parentType)) 633 t = parent; 634 else { 635 t = parent.predicate("fhir:"+parentType+'.'+name); 636 } 637 composeElement(t, "TriggerDefinition", name, element, index); 638 if (element.hasTypeElement()) 639 composeEnum(t, "TriggerDefinition", "type", element.getTypeElement(), -1); 640 if (element.hasEventNameElement()) 641 composeString(t, "TriggerDefinition", "eventName", element.getEventNameElement(), -1); 642 if (element.hasEventTiming()) 643 composeType(t, "TriggerDefinition", "eventTiming", element.getEventTiming(), -1); 644 if (element.hasEventData()) 645 composeDataRequirement(t, "TriggerDefinition", "eventData", element.getEventData(), -1); 646 } 647 648 protected void composeContributor(Complex parent, String parentType, String name, Contributor 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:"+parentType+'.'+name); 656 } 657 composeElement(t, "Contributor", name, element, index); 658 if (element.hasTypeElement()) 659 composeEnum(t, "Contributor", "type", element.getTypeElement(), -1); 660 if (element.hasNameElement()) 661 composeString(t, "Contributor", "name", element.getNameElement(), -1); 662 for (int i = 0; i < element.getContact().size(); i++) 663 composeContactDetail(t, "Contributor", "contact", element.getContact().get(i), i); 664 } 665 666 protected void composeDataRequirement(Complex parent, String parentType, String name, DataRequirement element, int index) { 667 if (element == null) 668 return; 669 Complex t; 670 if (Utilities.noString(parentType)) 671 t = parent; 672 else { 673 t = parent.predicate("fhir:"+parentType+'.'+name); 674 } 675 composeElement(t, "DataRequirement", name, element, index); 676 if (element.hasTypeElement()) 677 composeCode(t, "DataRequirement", "type", element.getTypeElement(), -1); 678 for (int i = 0; i < element.getProfile().size(); i++) 679 composeUri(t, "DataRequirement", "profile", element.getProfile().get(i), i); 680 for (int i = 0; i < element.getMustSupport().size(); i++) 681 composeString(t, "DataRequirement", "mustSupport", element.getMustSupport().get(i), i); 682 for (int i = 0; i < element.getCodeFilter().size(); i++) 683 composeDataRequirementDataRequirementCodeFilterComponent(t, "DataRequirement", "codeFilter", element.getCodeFilter().get(i), i); 684 for (int i = 0; i < element.getDateFilter().size(); i++) 685 composeDataRequirementDataRequirementDateFilterComponent(t, "DataRequirement", "dateFilter", element.getDateFilter().get(i), i); 686 } 687 688 protected void composeDataRequirementDataRequirementCodeFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementCodeFilterComponent element, int index) { 689 if (element == null) 690 return; 691 Complex t; 692 if (Utilities.noString(parentType)) 693 t = parent; 694 else { 695 t = parent.predicate("fhir:"+parentType+'.'+name); 696 } 697 composeElement(t, "codeFilter", name, element, index); 698 if (element.hasPathElement()) 699 composeString(t, "DataRequirement", "path", element.getPathElement(), -1); 700 if (element.hasValueSet()) 701 composeType(t, "DataRequirement", "valueSet", element.getValueSet(), -1); 702 for (int i = 0; i < element.getValueCode().size(); i++) 703 composeCode(t, "DataRequirement", "valueCode", element.getValueCode().get(i), i); 704 for (int i = 0; i < element.getValueCoding().size(); i++) 705 composeCoding(t, "DataRequirement", "valueCoding", element.getValueCoding().get(i), i); 706 for (int i = 0; i < element.getValueCodeableConcept().size(); i++) 707 composeCodeableConcept(t, "DataRequirement", "valueCodeableConcept", element.getValueCodeableConcept().get(i), i); 708 } 709 710 protected void composeDataRequirementDataRequirementDateFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementDateFilterComponent element, int index) { 711 if (element == null) 712 return; 713 Complex t; 714 if (Utilities.noString(parentType)) 715 t = parent; 716 else { 717 t = parent.predicate("fhir:"+parentType+'.'+name); 718 } 719 composeElement(t, "dateFilter", name, element, index); 720 if (element.hasPathElement()) 721 composeString(t, "DataRequirement", "path", element.getPathElement(), -1); 722 if (element.hasValue()) 723 composeType(t, "DataRequirement", "value", element.getValue(), -1); 724 } 725 726 protected void composeDosage(Complex parent, String parentType, String name, Dosage element, int index) { 727 if (element == null) 728 return; 729 Complex t; 730 if (Utilities.noString(parentType)) 731 t = parent; 732 else { 733 t = parent.predicate("fhir:"+parentType+'.'+name); 734 } 735 composeElement(t, "Dosage", name, element, index); 736 if (element.hasSequenceElement()) 737 composeInteger(t, "Dosage", "sequence", element.getSequenceElement(), -1); 738 if (element.hasTextElement()) 739 composeString(t, "Dosage", "text", element.getTextElement(), -1); 740 for (int i = 0; i < element.getAdditionalInstruction().size(); i++) 741 composeCodeableConcept(t, "Dosage", "additionalInstruction", element.getAdditionalInstruction().get(i), i); 742 if (element.hasPatientInstructionElement()) 743 composeString(t, "Dosage", "patientInstruction", element.getPatientInstructionElement(), -1); 744 if (element.hasTiming()) 745 composeTiming(t, "Dosage", "timing", element.getTiming(), -1); 746 if (element.hasAsNeeded()) 747 composeType(t, "Dosage", "asNeeded", element.getAsNeeded(), -1); 748 if (element.hasSite()) 749 composeCodeableConcept(t, "Dosage", "site", element.getSite(), -1); 750 if (element.hasRoute()) 751 composeCodeableConcept(t, "Dosage", "route", element.getRoute(), -1); 752 if (element.hasMethod()) 753 composeCodeableConcept(t, "Dosage", "method", element.getMethod(), -1); 754 if (element.hasDose()) 755 composeType(t, "Dosage", "dose", element.getDose(), -1); 756 if (element.hasMaxDosePerPeriod()) 757 composeRatio(t, "Dosage", "maxDosePerPeriod", element.getMaxDosePerPeriod(), -1); 758 if (element.hasMaxDosePerAdministration()) 759 composeQuantity(t, "Dosage", "maxDosePerAdministration", element.getMaxDosePerAdministration(), -1); 760 if (element.hasMaxDosePerLifetime()) 761 composeQuantity(t, "Dosage", "maxDosePerLifetime", element.getMaxDosePerLifetime(), -1); 762 if (element.hasRate()) 763 composeType(t, "Dosage", "rate", element.getRate(), -1); 764 } 765 766 protected void composeRelatedArtifact(Complex parent, String parentType, String name, RelatedArtifact element, int index) { 767 if (element == null) 768 return; 769 Complex t; 770 if (Utilities.noString(parentType)) 771 t = parent; 772 else { 773 t = parent.predicate("fhir:"+parentType+'.'+name); 774 } 775 composeElement(t, "RelatedArtifact", name, element, index); 776 if (element.hasTypeElement()) 777 composeEnum(t, "RelatedArtifact", "type", element.getTypeElement(), -1); 778 if (element.hasDisplayElement()) 779 composeString(t, "RelatedArtifact", "display", element.getDisplayElement(), -1); 780 if (element.hasCitationElement()) 781 composeString(t, "RelatedArtifact", "citation", element.getCitationElement(), -1); 782 if (element.hasUrlElement()) 783 composeUri(t, "RelatedArtifact", "url", element.getUrlElement(), -1); 784 if (element.hasDocument()) 785 composeAttachment(t, "RelatedArtifact", "document", element.getDocument(), -1); 786 if (element.hasResource()) 787 composeReference(t, "RelatedArtifact", "resource", element.getResource(), -1); 788 } 789 790 protected void composeContactDetail(Complex parent, String parentType, String name, ContactDetail element, int index) { 791 if (element == null) 792 return; 793 Complex t; 794 if (Utilities.noString(parentType)) 795 t = parent; 796 else { 797 t = parent.predicate("fhir:"+parentType+'.'+name); 798 } 799 composeElement(t, "ContactDetail", name, element, index); 800 if (element.hasNameElement()) 801 composeString(t, "ContactDetail", "name", element.getNameElement(), -1); 802 for (int i = 0; i < element.getTelecom().size(); i++) 803 composeContactPoint(t, "ContactDetail", "telecom", element.getTelecom().get(i), i); 804 } 805 806 protected void composeHumanName(Complex parent, String parentType, String name, HumanName element, int index) { 807 if (element == null) 808 return; 809 Complex t; 810 if (Utilities.noString(parentType)) 811 t = parent; 812 else { 813 t = parent.predicate("fhir:"+parentType+'.'+name); 814 } 815 composeElement(t, "HumanName", name, element, index); 816 if (element.hasUseElement()) 817 composeEnum(t, "HumanName", "use", element.getUseElement(), -1); 818 if (element.hasTextElement()) 819 composeString(t, "HumanName", "text", element.getTextElement(), -1); 820 if (element.hasFamilyElement()) 821 composeString(t, "HumanName", "family", element.getFamilyElement(), -1); 822 for (int i = 0; i < element.getGiven().size(); i++) 823 composeString(t, "HumanName", "given", element.getGiven().get(i), i); 824 for (int i = 0; i < element.getPrefix().size(); i++) 825 composeString(t, "HumanName", "prefix", element.getPrefix().get(i), i); 826 for (int i = 0; i < element.getSuffix().size(); i++) 827 composeString(t, "HumanName", "suffix", element.getSuffix().get(i), i); 828 if (element.hasPeriod()) 829 composePeriod(t, "HumanName", "period", element.getPeriod(), -1); 830 } 831 832 protected void composeContactPoint(Complex parent, String parentType, String name, ContactPoint element, int index) { 833 if (element == null) 834 return; 835 Complex t; 836 if (Utilities.noString(parentType)) 837 t = parent; 838 else { 839 t = parent.predicate("fhir:"+parentType+'.'+name); 840 } 841 composeElement(t, "ContactPoint", name, element, index); 842 if (element.hasSystemElement()) 843 composeEnum(t, "ContactPoint", "system", element.getSystemElement(), -1); 844 if (element.hasValueElement()) 845 composeString(t, "ContactPoint", "value", element.getValueElement(), -1); 846 if (element.hasUseElement()) 847 composeEnum(t, "ContactPoint", "use", element.getUseElement(), -1); 848 if (element.hasRankElement()) 849 composePositiveInt(t, "ContactPoint", "rank", element.getRankElement(), -1); 850 if (element.hasPeriod()) 851 composePeriod(t, "ContactPoint", "period", element.getPeriod(), -1); 852 } 853 854 protected void composeUsageContext(Complex parent, String parentType, String name, UsageContext element, int index) { 855 if (element == null) 856 return; 857 Complex t; 858 if (Utilities.noString(parentType)) 859 t = parent; 860 else { 861 t = parent.predicate("fhir:"+parentType+'.'+name); 862 } 863 composeElement(t, "UsageContext", name, element, index); 864 if (element.hasCode()) 865 composeCoding(t, "UsageContext", "code", element.getCode(), -1); 866 if (element.hasValue()) 867 composeType(t, "UsageContext", "value", element.getValue(), -1); 868 } 869 870 protected void composeTiming(Complex parent, String parentType, String name, Timing element, int index) { 871 if (element == null) 872 return; 873 Complex t; 874 if (Utilities.noString(parentType)) 875 t = parent; 876 else { 877 t = parent.predicate("fhir:"+parentType+'.'+name); 878 } 879 composeElement(t, "Timing", name, element, index); 880 for (int i = 0; i < element.getEvent().size(); i++) 881 composeDateTime(t, "Timing", "event", element.getEvent().get(i), i); 882 if (element.hasRepeat()) 883 composeTimingTimingRepeatComponent(t, "Timing", "repeat", element.getRepeat(), -1); 884 if (element.hasCode()) 885 composeCodeableConcept(t, "Timing", "code", element.getCode(), -1); 886 } 887 888 protected void composeTimingTimingRepeatComponent(Complex parent, String parentType, String name, Timing.TimingRepeatComponent element, int index) { 889 if (element == null) 890 return; 891 Complex t; 892 if (Utilities.noString(parentType)) 893 t = parent; 894 else { 895 t = parent.predicate("fhir:"+parentType+'.'+name); 896 } 897 composeElement(t, "repeat", name, element, index); 898 if (element.hasBounds()) 899 composeType(t, "Timing", "bounds", element.getBounds(), -1); 900 if (element.hasCountElement()) 901 composeInteger(t, "Timing", "count", element.getCountElement(), -1); 902 if (element.hasCountMaxElement()) 903 composeInteger(t, "Timing", "countMax", element.getCountMaxElement(), -1); 904 if (element.hasDurationElement()) 905 composeDecimal(t, "Timing", "duration", element.getDurationElement(), -1); 906 if (element.hasDurationMaxElement()) 907 composeDecimal(t, "Timing", "durationMax", element.getDurationMaxElement(), -1); 908 if (element.hasDurationUnitElement()) 909 composeEnum(t, "Timing", "durationUnit", element.getDurationUnitElement(), -1); 910 if (element.hasFrequencyElement()) 911 composeInteger(t, "Timing", "frequency", element.getFrequencyElement(), -1); 912 if (element.hasFrequencyMaxElement()) 913 composeInteger(t, "Timing", "frequencyMax", element.getFrequencyMaxElement(), -1); 914 if (element.hasPeriodElement()) 915 composeDecimal(t, "Timing", "period", element.getPeriodElement(), -1); 916 if (element.hasPeriodMaxElement()) 917 composeDecimal(t, "Timing", "periodMax", element.getPeriodMaxElement(), -1); 918 if (element.hasPeriodUnitElement()) 919 composeEnum(t, "Timing", "periodUnit", element.getPeriodUnitElement(), -1); 920 for (int i = 0; i < element.getDayOfWeek().size(); i++) 921 composeEnum(t, "Timing", "dayOfWeek", element.getDayOfWeek().get(i), i); 922 for (int i = 0; i < element.getTimeOfDay().size(); i++) 923 composeTime(t, "Timing", "timeOfDay", element.getTimeOfDay().get(i), i); 924 for (int i = 0; i < element.getWhen().size(); i++) 925 composeEnum(t, "Timing", "when", element.getWhen().get(i), i); 926 if (element.hasOffsetElement()) 927 composeUnsignedInt(t, "Timing", "offset", element.getOffsetElement(), -1); 928 } 929 930 protected void composeElementDefinition(Complex parent, String parentType, String name, ElementDefinition 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:"+parentType+'.'+name); 938 } 939 composeElement(t, "ElementDefinition", name, element, index); 940 if (element.hasPathElement()) 941 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 942 for (int i = 0; i < element.getRepresentation().size(); i++) 943 composeEnum(t, "ElementDefinition", "representation", element.getRepresentation().get(i), i); 944 if (element.hasSliceNameElement()) 945 composeString(t, "ElementDefinition", "sliceName", element.getSliceNameElement(), -1); 946 if (element.hasLabelElement()) 947 composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1); 948 for (int i = 0; i < element.getCode().size(); i++) 949 composeCoding(t, "ElementDefinition", "code", element.getCode().get(i), i); 950 if (element.hasSlicing()) 951 composeElementDefinitionElementDefinitionSlicingComponent(t, "ElementDefinition", "slicing", element.getSlicing(), -1); 952 if (element.hasShortElement()) 953 composeString(t, "ElementDefinition", "short", element.getShortElement(), -1); 954 if (element.hasDefinitionElement()) 955 composeMarkdown(t, "ElementDefinition", "definition", element.getDefinitionElement(), -1); 956 if (element.hasCommentElement()) 957 composeMarkdown(t, "ElementDefinition", "comment", element.getCommentElement(), -1); 958 if (element.hasRequirementsElement()) 959 composeMarkdown(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1); 960 for (int i = 0; i < element.getAlias().size(); i++) 961 composeString(t, "ElementDefinition", "alias", element.getAlias().get(i), i); 962 if (element.hasMinElement()) 963 composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1); 964 if (element.hasMaxElement()) 965 composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1); 966 if (element.hasBase()) 967 composeElementDefinitionElementDefinitionBaseComponent(t, "ElementDefinition", "base", element.getBase(), -1); 968 if (element.hasContentReferenceElement()) 969 composeUri(t, "ElementDefinition", "contentReference", element.getContentReferenceElement(), -1); 970 for (int i = 0; i < element.getType().size(); i++) 971 composeElementDefinitionTypeRefComponent(t, "ElementDefinition", "type", element.getType().get(i), i); 972 if (element.hasDefaultValue()) 973 composeType(t, "ElementDefinition", "defaultValue", element.getDefaultValue(), -1); 974 if (element.hasMeaningWhenMissingElement()) 975 composeMarkdown(t, "ElementDefinition", "meaningWhenMissing", element.getMeaningWhenMissingElement(), -1); 976 if (element.hasOrderMeaningElement()) 977 composeString(t, "ElementDefinition", "orderMeaning", element.getOrderMeaningElement(), -1); 978 if (element.hasFixed()) 979 composeType(t, "ElementDefinition", "fixed", element.getFixed(), -1); 980 if (element.hasPattern()) 981 composeType(t, "ElementDefinition", "pattern", element.getPattern(), -1); 982 for (int i = 0; i < element.getExample().size(); i++) 983 composeElementDefinitionElementDefinitionExampleComponent(t, "ElementDefinition", "example", element.getExample().get(i), i); 984 if (element.hasMinValue()) 985 composeType(t, "ElementDefinition", "minValue", element.getMinValue(), -1); 986 if (element.hasMaxValue()) 987 composeType(t, "ElementDefinition", "maxValue", element.getMaxValue(), -1); 988 if (element.hasMaxLengthElement()) 989 composeInteger(t, "ElementDefinition", "maxLength", element.getMaxLengthElement(), -1); 990 for (int i = 0; i < element.getCondition().size(); i++) 991 composeId(t, "ElementDefinition", "condition", element.getCondition().get(i), i); 992 for (int i = 0; i < element.getConstraint().size(); i++) 993 composeElementDefinitionElementDefinitionConstraintComponent(t, "ElementDefinition", "constraint", element.getConstraint().get(i), i); 994 if (element.hasMustSupportElement()) 995 composeBoolean(t, "ElementDefinition", "mustSupport", element.getMustSupportElement(), -1); 996 if (element.hasIsModifierElement()) 997 composeBoolean(t, "ElementDefinition", "isModifier", element.getIsModifierElement(), -1); 998 if (element.hasIsSummaryElement()) 999 composeBoolean(t, "ElementDefinition", "isSummary", element.getIsSummaryElement(), -1); 1000 if (element.hasBinding()) 1001 composeElementDefinitionElementDefinitionBindingComponent(t, "ElementDefinition", "binding", element.getBinding(), -1); 1002 for (int i = 0; i < element.getMapping().size(); i++) 1003 composeElementDefinitionElementDefinitionMappingComponent(t, "ElementDefinition", "mapping", element.getMapping().get(i), i); 1004 } 1005 1006 protected void composeElementDefinitionElementDefinitionSlicingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingComponent element, int index) { 1007 if (element == null) 1008 return; 1009 Complex t; 1010 if (Utilities.noString(parentType)) 1011 t = parent; 1012 else { 1013 t = parent.predicate("fhir:"+parentType+'.'+name); 1014 } 1015 composeElement(t, "slicing", name, element, index); 1016 for (int i = 0; i < element.getDiscriminator().size(); i++) 1017 composeElementDefinitionElementDefinitionSlicingDiscriminatorComponent(t, "ElementDefinition", "discriminator", element.getDiscriminator().get(i), i); 1018 if (element.hasDescriptionElement()) 1019 composeString(t, "ElementDefinition", "description", element.getDescriptionElement(), -1); 1020 if (element.hasOrderedElement()) 1021 composeBoolean(t, "ElementDefinition", "ordered", element.getOrderedElement(), -1); 1022 if (element.hasRulesElement()) 1023 composeEnum(t, "ElementDefinition", "rules", element.getRulesElement(), -1); 1024 } 1025 1026 protected void composeElementDefinitionElementDefinitionSlicingDiscriminatorComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent element, int index) { 1027 if (element == null) 1028 return; 1029 Complex t; 1030 if (Utilities.noString(parentType)) 1031 t = parent; 1032 else { 1033 t = parent.predicate("fhir:"+parentType+'.'+name); 1034 } 1035 composeElement(t, "discriminator", name, element, index); 1036 if (element.hasTypeElement()) 1037 composeEnum(t, "ElementDefinition", "type", element.getTypeElement(), -1); 1038 if (element.hasPathElement()) 1039 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 1040 } 1041 1042 protected void composeElementDefinitionElementDefinitionBaseComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBaseComponent element, int index) { 1043 if (element == null) 1044 return; 1045 Complex t; 1046 if (Utilities.noString(parentType)) 1047 t = parent; 1048 else { 1049 t = parent.predicate("fhir:"+parentType+'.'+name); 1050 } 1051 composeElement(t, "base", name, element, index); 1052 if (element.hasPathElement()) 1053 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 1054 if (element.hasMinElement()) 1055 composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1); 1056 if (element.hasMaxElement()) 1057 composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1); 1058 } 1059 1060 protected void composeElementDefinitionTypeRefComponent(Complex parent, String parentType, String name, ElementDefinition.TypeRefComponent element, int index) { 1061 if (element == null) 1062 return; 1063 Complex t; 1064 if (Utilities.noString(parentType)) 1065 t = parent; 1066 else { 1067 t = parent.predicate("fhir:"+parentType+'.'+name); 1068 } 1069 composeElement(t, "type", name, element, index); 1070 if (element.hasCodeElement()) 1071 composeUri(t, "ElementDefinition", "code", element.getCodeElement(), -1); 1072 if (element.hasProfileElement()) 1073 composeUri(t, "ElementDefinition", "profile", element.getProfileElement(), -1); 1074 if (element.hasTargetProfileElement()) 1075 composeUri(t, "ElementDefinition", "targetProfile", element.getTargetProfileElement(), -1); 1076 for (int i = 0; i < element.getAggregation().size(); i++) 1077 composeEnum(t, "ElementDefinition", "aggregation", element.getAggregation().get(i), i); 1078 if (element.hasVersioningElement()) 1079 composeEnum(t, "ElementDefinition", "versioning", element.getVersioningElement(), -1); 1080 } 1081 1082 protected void composeElementDefinitionElementDefinitionExampleComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionExampleComponent element, int index) { 1083 if (element == null) 1084 return; 1085 Complex t; 1086 if (Utilities.noString(parentType)) 1087 t = parent; 1088 else { 1089 t = parent.predicate("fhir:"+parentType+'.'+name); 1090 } 1091 composeElement(t, "example", name, element, index); 1092 if (element.hasLabelElement()) 1093 composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1); 1094 if (element.hasValue()) 1095 composeType(t, "ElementDefinition", "value", element.getValue(), -1); 1096 } 1097 1098 protected void composeElementDefinitionElementDefinitionConstraintComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionConstraintComponent element, int index) { 1099 if (element == null) 1100 return; 1101 Complex t; 1102 if (Utilities.noString(parentType)) 1103 t = parent; 1104 else { 1105 t = parent.predicate("fhir:"+parentType+'.'+name); 1106 } 1107 composeElement(t, "constraint", name, element, index); 1108 if (element.hasKeyElement()) 1109 composeId(t, "ElementDefinition", "key", element.getKeyElement(), -1); 1110 if (element.hasRequirementsElement()) 1111 composeString(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1); 1112 if (element.hasSeverityElement()) 1113 composeEnum(t, "ElementDefinition", "severity", element.getSeverityElement(), -1); 1114 if (element.hasHumanElement()) 1115 composeString(t, "ElementDefinition", "human", element.getHumanElement(), -1); 1116 if (element.hasExpressionElement()) 1117 composeString(t, "ElementDefinition", "expression", element.getExpressionElement(), -1); 1118 if (element.hasXpathElement()) 1119 composeString(t, "ElementDefinition", "xpath", element.getXpathElement(), -1); 1120 if (element.hasSourceElement()) 1121 composeUri(t, "ElementDefinition", "source", element.getSourceElement(), -1); 1122 } 1123 1124 protected void composeElementDefinitionElementDefinitionBindingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingComponent element, int index) { 1125 if (element == null) 1126 return; 1127 Complex t; 1128 if (Utilities.noString(parentType)) 1129 t = parent; 1130 else { 1131 t = parent.predicate("fhir:"+parentType+'.'+name); 1132 } 1133 composeElement(t, "binding", name, element, index); 1134 if (element.hasStrengthElement()) 1135 composeEnum(t, "ElementDefinition", "strength", element.getStrengthElement(), -1); 1136 if (element.hasDescriptionElement()) 1137 composeString(t, "ElementDefinition", "description", element.getDescriptionElement(), -1); 1138 if (element.hasValueSet()) 1139 composeType(t, "ElementDefinition", "valueSet", element.getValueSet(), -1); 1140 } 1141 1142 protected void composeElementDefinitionElementDefinitionMappingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionMappingComponent element, int index) { 1143 if (element == null) 1144 return; 1145 Complex t; 1146 if (Utilities.noString(parentType)) 1147 t = parent; 1148 else { 1149 t = parent.predicate("fhir:"+parentType+'.'+name); 1150 } 1151 composeElement(t, "mapping", name, element, index); 1152 if (element.hasIdentityElement()) 1153 composeId(t, "ElementDefinition", "identity", element.getIdentityElement(), -1); 1154 if (element.hasLanguageElement()) 1155 composeCode(t, "ElementDefinition", "language", element.getLanguageElement(), -1); 1156 if (element.hasMapElement()) 1157 composeString(t, "ElementDefinition", "map", element.getMapElement(), -1); 1158 if (element.hasCommentElement()) 1159 composeString(t, "ElementDefinition", "comment", element.getCommentElement(), -1); 1160 } 1161 1162 protected void composeParameterDefinition(Complex parent, String parentType, String name, ParameterDefinition element, int index) { 1163 if (element == null) 1164 return; 1165 Complex t; 1166 if (Utilities.noString(parentType)) 1167 t = parent; 1168 else { 1169 t = parent.predicate("fhir:"+parentType+'.'+name); 1170 } 1171 composeElement(t, "ParameterDefinition", name, element, index); 1172 if (element.hasNameElement()) 1173 composeCode(t, "ParameterDefinition", "name", element.getNameElement(), -1); 1174 if (element.hasUseElement()) 1175 composeEnum(t, "ParameterDefinition", "use", element.getUseElement(), -1); 1176 if (element.hasMinElement()) 1177 composeInteger(t, "ParameterDefinition", "min", element.getMinElement(), -1); 1178 if (element.hasMaxElement()) 1179 composeString(t, "ParameterDefinition", "max", element.getMaxElement(), -1); 1180 if (element.hasDocumentationElement()) 1181 composeString(t, "ParameterDefinition", "documentation", element.getDocumentationElement(), -1); 1182 if (element.hasTypeElement()) 1183 composeCode(t, "ParameterDefinition", "type", element.getTypeElement(), -1); 1184 if (element.hasProfile()) 1185 composeReference(t, "ParameterDefinition", "profile", element.getProfile(), -1); 1186 } 1187 1188 protected void composeDomainResource(Complex t, String parentType, String name, DomainResource element, int index) { 1189 composeResource(t, parentType, name, element, index); 1190 if (element.hasText()) 1191 composeNarrative(t, "DomainResource", "text", element.getText(), -1); 1192 for (int i = 0; i < element.getContained().size(); i++) 1193 composeResource(t, "DomainResource", "contained", element.getContained().get(i), i); 1194 for (int i = 0; i < element.getExtension().size(); i++) 1195 composeExtension(t, "DomainResource", "extension", element.getExtension().get(i), i); 1196 for (int i = 0; i < element.getModifierExtension().size(); i++) 1197 composeExtension(t, "DomainResource", "modifierExtension", element.getModifierExtension().get(i), i); 1198 } 1199 1200 protected void composeParameters(Complex parent, String parentType, String name, Parameters element, int index) { 1201 if (element == null) 1202 return; 1203 Complex t; 1204 if (Utilities.noString(parentType)) 1205 t = parent; 1206 else { 1207 t = parent.predicate("fhir:"+parentType+'.'+name); 1208 } 1209 composeResource(t, "Parameters", name, element, index); 1210 for (int i = 0; i < element.getParameter().size(); i++) 1211 composeParametersParametersParameterComponent(t, "Parameters", "parameter", element.getParameter().get(i), i); 1212 } 1213 1214 protected void composeParametersParametersParameterComponent(Complex parent, String parentType, String name, Parameters.ParametersParameterComponent element, int index) { 1215 if (element == null) 1216 return; 1217 Complex t; 1218 if (Utilities.noString(parentType)) 1219 t = parent; 1220 else { 1221 t = parent.predicate("fhir:"+parentType+'.'+name); 1222 } 1223 composeBackboneElement(t, "parameter", name, element, index); 1224 if (element.hasNameElement()) 1225 composeString(t, "Parameters", "name", element.getNameElement(), -1); 1226 if (element.hasValue()) 1227 composeType(t, "Parameters", "value", element.getValue(), -1); 1228 if (element.hasResource()) 1229 composeResource(t, "Parameters", "resource", element.getResource(), -1); 1230 for (int i = 0; i < element.getPart().size(); i++) 1231 composeParametersParametersParameterComponent(t, "Parameters", "part", element.getPart().get(i), i); 1232 } 1233 1234 protected void composeResource(Complex t, String parentType, String name, Resource element, int index) { 1235 if (element.hasIdElement()) 1236 composeId(t, "Resource", "id", element.getIdElement(), -1); 1237 if (element.hasMeta()) 1238 composeMeta(t, "Resource", "meta", element.getMeta(), -1); 1239 if (element.hasImplicitRulesElement()) 1240 composeUri(t, "Resource", "implicitRules", element.getImplicitRulesElement(), -1); 1241 if (element.hasLanguageElement()) 1242 composeCode(t, "Resource", "language", element.getLanguageElement(), -1); 1243 } 1244 1245 protected void composeAccount(Complex parent, String parentType, String name, Account element, int index) { 1246 if (element == null) 1247 return; 1248 Complex t; 1249 if (Utilities.noString(parentType)) 1250 t = parent; 1251 else { 1252 t = parent.predicate("fhir:"+parentType+'.'+name); 1253 } 1254 composeDomainResource(t, "Account", name, element, index); 1255 for (int i = 0; i < element.getIdentifier().size(); i++) 1256 composeIdentifier(t, "Account", "identifier", element.getIdentifier().get(i), i); 1257 if (element.hasStatusElement()) 1258 composeEnum(t, "Account", "status", element.getStatusElement(), -1); 1259 if (element.hasType()) 1260 composeCodeableConcept(t, "Account", "type", element.getType(), -1); 1261 if (element.hasNameElement()) 1262 composeString(t, "Account", "name", element.getNameElement(), -1); 1263 if (element.hasSubject()) 1264 composeReference(t, "Account", "subject", element.getSubject(), -1); 1265 if (element.hasPeriod()) 1266 composePeriod(t, "Account", "period", element.getPeriod(), -1); 1267 if (element.hasActive()) 1268 composePeriod(t, "Account", "active", element.getActive(), -1); 1269 if (element.hasBalance()) 1270 composeMoney(t, "Account", "balance", element.getBalance(), -1); 1271 for (int i = 0; i < element.getCoverage().size(); i++) 1272 composeAccountCoverageComponent(t, "Account", "coverage", element.getCoverage().get(i), i); 1273 if (element.hasOwner()) 1274 composeReference(t, "Account", "owner", element.getOwner(), -1); 1275 if (element.hasDescriptionElement()) 1276 composeString(t, "Account", "description", element.getDescriptionElement(), -1); 1277 for (int i = 0; i < element.getGuarantor().size(); i++) 1278 composeAccountGuarantorComponent(t, "Account", "guarantor", element.getGuarantor().get(i), i); 1279 } 1280 1281 protected void composeAccountCoverageComponent(Complex parent, String parentType, String name, Account.CoverageComponent element, int index) { 1282 if (element == null) 1283 return; 1284 Complex t; 1285 if (Utilities.noString(parentType)) 1286 t = parent; 1287 else { 1288 t = parent.predicate("fhir:"+parentType+'.'+name); 1289 } 1290 composeBackboneElement(t, "coverage", name, element, index); 1291 if (element.hasCoverage()) 1292 composeReference(t, "Account", "coverage", element.getCoverage(), -1); 1293 if (element.hasPriorityElement()) 1294 composePositiveInt(t, "Account", "priority", element.getPriorityElement(), -1); 1295 } 1296 1297 protected void composeAccountGuarantorComponent(Complex parent, String parentType, String name, Account.GuarantorComponent element, int index) { 1298 if (element == null) 1299 return; 1300 Complex t; 1301 if (Utilities.noString(parentType)) 1302 t = parent; 1303 else { 1304 t = parent.predicate("fhir:"+parentType+'.'+name); 1305 } 1306 composeBackboneElement(t, "guarantor", name, element, index); 1307 if (element.hasParty()) 1308 composeReference(t, "Account", "party", element.getParty(), -1); 1309 if (element.hasOnHoldElement()) 1310 composeBoolean(t, "Account", "onHold", element.getOnHoldElement(), -1); 1311 if (element.hasPeriod()) 1312 composePeriod(t, "Account", "period", element.getPeriod(), -1); 1313 } 1314 1315 protected void composeActivityDefinition(Complex parent, String parentType, String name, ActivityDefinition element, int index) { 1316 if (element == null) 1317 return; 1318 Complex t; 1319 if (Utilities.noString(parentType)) 1320 t = parent; 1321 else { 1322 t = parent.predicate("fhir:"+parentType+'.'+name); 1323 } 1324 composeDomainResource(t, "ActivityDefinition", name, element, index); 1325 if (element.hasUrlElement()) 1326 composeUri(t, "ActivityDefinition", "url", element.getUrlElement(), -1); 1327 for (int i = 0; i < element.getIdentifier().size(); i++) 1328 composeIdentifier(t, "ActivityDefinition", "identifier", element.getIdentifier().get(i), i); 1329 if (element.hasVersionElement()) 1330 composeString(t, "ActivityDefinition", "version", element.getVersionElement(), -1); 1331 if (element.hasNameElement()) 1332 composeString(t, "ActivityDefinition", "name", element.getNameElement(), -1); 1333 if (element.hasTitleElement()) 1334 composeString(t, "ActivityDefinition", "title", element.getTitleElement(), -1); 1335 if (element.hasStatusElement()) 1336 composeEnum(t, "ActivityDefinition", "status", element.getStatusElement(), -1); 1337 if (element.hasExperimentalElement()) 1338 composeBoolean(t, "ActivityDefinition", "experimental", element.getExperimentalElement(), -1); 1339 if (element.hasDateElement()) 1340 composeDateTime(t, "ActivityDefinition", "date", element.getDateElement(), -1); 1341 if (element.hasPublisherElement()) 1342 composeString(t, "ActivityDefinition", "publisher", element.getPublisherElement(), -1); 1343 if (element.hasDescriptionElement()) 1344 composeMarkdown(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1); 1345 if (element.hasPurposeElement()) 1346 composeMarkdown(t, "ActivityDefinition", "purpose", element.getPurposeElement(), -1); 1347 if (element.hasUsageElement()) 1348 composeString(t, "ActivityDefinition", "usage", element.getUsageElement(), -1); 1349 if (element.hasApprovalDateElement()) 1350 composeDate(t, "ActivityDefinition", "approvalDate", element.getApprovalDateElement(), -1); 1351 if (element.hasLastReviewDateElement()) 1352 composeDate(t, "ActivityDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 1353 if (element.hasEffectivePeriod()) 1354 composePeriod(t, "ActivityDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 1355 for (int i = 0; i < element.getUseContext().size(); i++) 1356 composeUsageContext(t, "ActivityDefinition", "useContext", element.getUseContext().get(i), i); 1357 for (int i = 0; i < element.getJurisdiction().size(); i++) 1358 composeCodeableConcept(t, "ActivityDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 1359 for (int i = 0; i < element.getTopic().size(); i++) 1360 composeCodeableConcept(t, "ActivityDefinition", "topic", element.getTopic().get(i), i); 1361 for (int i = 0; i < element.getContributor().size(); i++) 1362 composeContributor(t, "ActivityDefinition", "contributor", element.getContributor().get(i), i); 1363 for (int i = 0; i < element.getContact().size(); i++) 1364 composeContactDetail(t, "ActivityDefinition", "contact", element.getContact().get(i), i); 1365 if (element.hasCopyrightElement()) 1366 composeMarkdown(t, "ActivityDefinition", "copyright", element.getCopyrightElement(), -1); 1367 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 1368 composeRelatedArtifact(t, "ActivityDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 1369 for (int i = 0; i < element.getLibrary().size(); i++) 1370 composeReference(t, "ActivityDefinition", "library", element.getLibrary().get(i), i); 1371 if (element.hasKindElement()) 1372 composeEnum(t, "ActivityDefinition", "kind", element.getKindElement(), -1); 1373 if (element.hasCode()) 1374 composeCodeableConcept(t, "ActivityDefinition", "code", element.getCode(), -1); 1375 if (element.hasTiming()) 1376 composeType(t, "ActivityDefinition", "timing", element.getTiming(), -1); 1377 if (element.hasLocation()) 1378 composeReference(t, "ActivityDefinition", "location", element.getLocation(), -1); 1379 for (int i = 0; i < element.getParticipant().size(); i++) 1380 composeActivityDefinitionActivityDefinitionParticipantComponent(t, "ActivityDefinition", "participant", element.getParticipant().get(i), i); 1381 if (element.hasProduct()) 1382 composeType(t, "ActivityDefinition", "product", element.getProduct(), -1); 1383 if (element.hasQuantity()) 1384 composeQuantity(t, "ActivityDefinition", "quantity", element.getQuantity(), -1); 1385 for (int i = 0; i < element.getDosage().size(); i++) 1386 composeDosage(t, "ActivityDefinition", "dosage", element.getDosage().get(i), i); 1387 for (int i = 0; i < element.getBodySite().size(); i++) 1388 composeCodeableConcept(t, "ActivityDefinition", "bodySite", element.getBodySite().get(i), i); 1389 if (element.hasTransform()) 1390 composeReference(t, "ActivityDefinition", "transform", element.getTransform(), -1); 1391 for (int i = 0; i < element.getDynamicValue().size(); i++) 1392 composeActivityDefinitionActivityDefinitionDynamicValueComponent(t, "ActivityDefinition", "dynamicValue", element.getDynamicValue().get(i), i); 1393 } 1394 1395 protected void composeActivityDefinitionActivityDefinitionParticipantComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionParticipantComponent element, int index) { 1396 if (element == null) 1397 return; 1398 Complex t; 1399 if (Utilities.noString(parentType)) 1400 t = parent; 1401 else { 1402 t = parent.predicate("fhir:"+parentType+'.'+name); 1403 } 1404 composeBackboneElement(t, "participant", name, element, index); 1405 if (element.hasTypeElement()) 1406 composeEnum(t, "ActivityDefinition", "type", element.getTypeElement(), -1); 1407 if (element.hasRole()) 1408 composeCodeableConcept(t, "ActivityDefinition", "role", element.getRole(), -1); 1409 } 1410 1411 protected void composeActivityDefinitionActivityDefinitionDynamicValueComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionDynamicValueComponent element, int index) { 1412 if (element == null) 1413 return; 1414 Complex t; 1415 if (Utilities.noString(parentType)) 1416 t = parent; 1417 else { 1418 t = parent.predicate("fhir:"+parentType+'.'+name); 1419 } 1420 composeBackboneElement(t, "dynamicValue", name, element, index); 1421 if (element.hasDescriptionElement()) 1422 composeString(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1); 1423 if (element.hasPathElement()) 1424 composeString(t, "ActivityDefinition", "path", element.getPathElement(), -1); 1425 if (element.hasLanguageElement()) 1426 composeString(t, "ActivityDefinition", "language", element.getLanguageElement(), -1); 1427 if (element.hasExpressionElement()) 1428 composeString(t, "ActivityDefinition", "expression", element.getExpressionElement(), -1); 1429 } 1430 1431 protected void composeAdverseEvent(Complex parent, String parentType, String name, AdverseEvent element, int index) { 1432 if (element == null) 1433 return; 1434 Complex t; 1435 if (Utilities.noString(parentType)) 1436 t = parent; 1437 else { 1438 t = parent.predicate("fhir:"+parentType+'.'+name); 1439 } 1440 composeDomainResource(t, "AdverseEvent", name, element, index); 1441 if (element.hasIdentifier()) 1442 composeIdentifier(t, "AdverseEvent", "identifier", element.getIdentifier(), -1); 1443 if (element.hasCategoryElement()) 1444 composeEnum(t, "AdverseEvent", "category", element.getCategoryElement(), -1); 1445 if (element.hasType()) 1446 composeCodeableConcept(t, "AdverseEvent", "type", element.getType(), -1); 1447 if (element.hasSubject()) 1448 composeReference(t, "AdverseEvent", "subject", element.getSubject(), -1); 1449 if (element.hasDateElement()) 1450 composeDateTime(t, "AdverseEvent", "date", element.getDateElement(), -1); 1451 for (int i = 0; i < element.getReaction().size(); i++) 1452 composeReference(t, "AdverseEvent", "reaction", element.getReaction().get(i), i); 1453 if (element.hasLocation()) 1454 composeReference(t, "AdverseEvent", "location", element.getLocation(), -1); 1455 if (element.hasSeriousness()) 1456 composeCodeableConcept(t, "AdverseEvent", "seriousness", element.getSeriousness(), -1); 1457 if (element.hasOutcome()) 1458 composeCodeableConcept(t, "AdverseEvent", "outcome", element.getOutcome(), -1); 1459 if (element.hasRecorder()) 1460 composeReference(t, "AdverseEvent", "recorder", element.getRecorder(), -1); 1461 if (element.hasEventParticipant()) 1462 composeReference(t, "AdverseEvent", "eventParticipant", element.getEventParticipant(), -1); 1463 if (element.hasDescriptionElement()) 1464 composeString(t, "AdverseEvent", "description", element.getDescriptionElement(), -1); 1465 for (int i = 0; i < element.getSuspectEntity().size(); i++) 1466 composeAdverseEventAdverseEventSuspectEntityComponent(t, "AdverseEvent", "suspectEntity", element.getSuspectEntity().get(i), i); 1467 for (int i = 0; i < element.getSubjectMedicalHistory().size(); i++) 1468 composeReference(t, "AdverseEvent", "subjectMedicalHistory", element.getSubjectMedicalHistory().get(i), i); 1469 for (int i = 0; i < element.getReferenceDocument().size(); i++) 1470 composeReference(t, "AdverseEvent", "referenceDocument", element.getReferenceDocument().get(i), i); 1471 for (int i = 0; i < element.getStudy().size(); i++) 1472 composeReference(t, "AdverseEvent", "study", element.getStudy().get(i), i); 1473 } 1474 1475 protected void composeAdverseEventAdverseEventSuspectEntityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityComponent element, int index) { 1476 if (element == null) 1477 return; 1478 Complex t; 1479 if (Utilities.noString(parentType)) 1480 t = parent; 1481 else { 1482 t = parent.predicate("fhir:"+parentType+'.'+name); 1483 } 1484 composeBackboneElement(t, "suspectEntity", name, element, index); 1485 if (element.hasInstance()) 1486 composeReference(t, "AdverseEvent", "instance", element.getInstance(), -1); 1487 if (element.hasCausalityElement()) 1488 composeEnum(t, "AdverseEvent", "causality", element.getCausalityElement(), -1); 1489 if (element.hasCausalityAssessment()) 1490 composeCodeableConcept(t, "AdverseEvent", "causalityAssessment", element.getCausalityAssessment(), -1); 1491 if (element.hasCausalityProductRelatednessElement()) 1492 composeString(t, "AdverseEvent", "causalityProductRelatedness", element.getCausalityProductRelatednessElement(), -1); 1493 if (element.hasCausalityMethod()) 1494 composeCodeableConcept(t, "AdverseEvent", "causalityMethod", element.getCausalityMethod(), -1); 1495 if (element.hasCausalityAuthor()) 1496 composeReference(t, "AdverseEvent", "causalityAuthor", element.getCausalityAuthor(), -1); 1497 if (element.hasCausalityResult()) 1498 composeCodeableConcept(t, "AdverseEvent", "causalityResult", element.getCausalityResult(), -1); 1499 } 1500 1501 protected void composeAllergyIntolerance(Complex parent, String parentType, String name, AllergyIntolerance element, int index) { 1502 if (element == null) 1503 return; 1504 Complex t; 1505 if (Utilities.noString(parentType)) 1506 t = parent; 1507 else { 1508 t = parent.predicate("fhir:"+parentType+'.'+name); 1509 } 1510 composeDomainResource(t, "AllergyIntolerance", name, element, index); 1511 for (int i = 0; i < element.getIdentifier().size(); i++) 1512 composeIdentifier(t, "AllergyIntolerance", "identifier", element.getIdentifier().get(i), i); 1513 if (element.hasClinicalStatusElement()) 1514 composeEnum(t, "AllergyIntolerance", "clinicalStatus", element.getClinicalStatusElement(), -1); 1515 if (element.hasVerificationStatusElement()) 1516 composeEnum(t, "AllergyIntolerance", "verificationStatus", element.getVerificationStatusElement(), -1); 1517 if (element.hasTypeElement()) 1518 composeEnum(t, "AllergyIntolerance", "type", element.getTypeElement(), -1); 1519 for (int i = 0; i < element.getCategory().size(); i++) 1520 composeEnum(t, "AllergyIntolerance", "category", element.getCategory().get(i), i); 1521 if (element.hasCriticalityElement()) 1522 composeEnum(t, "AllergyIntolerance", "criticality", element.getCriticalityElement(), -1); 1523 if (element.hasCode()) 1524 composeCodeableConcept(t, "AllergyIntolerance", "code", element.getCode(), -1); 1525 if (element.hasPatient()) 1526 composeReference(t, "AllergyIntolerance", "patient", element.getPatient(), -1); 1527 if (element.hasOnset()) 1528 composeType(t, "AllergyIntolerance", "onset", element.getOnset(), -1); 1529 if (element.hasAssertedDateElement()) 1530 composeDateTime(t, "AllergyIntolerance", "assertedDate", element.getAssertedDateElement(), -1); 1531 if (element.hasRecorder()) 1532 composeReference(t, "AllergyIntolerance", "recorder", element.getRecorder(), -1); 1533 if (element.hasAsserter()) 1534 composeReference(t, "AllergyIntolerance", "asserter", element.getAsserter(), -1); 1535 if (element.hasLastOccurrenceElement()) 1536 composeDateTime(t, "AllergyIntolerance", "lastOccurrence", element.getLastOccurrenceElement(), -1); 1537 for (int i = 0; i < element.getNote().size(); i++) 1538 composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i); 1539 for (int i = 0; i < element.getReaction().size(); i++) 1540 composeAllergyIntoleranceAllergyIntoleranceReactionComponent(t, "AllergyIntolerance", "reaction", element.getReaction().get(i), i); 1541 } 1542 1543 protected void composeAllergyIntoleranceAllergyIntoleranceReactionComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceReactionComponent element, int index) { 1544 if (element == null) 1545 return; 1546 Complex t; 1547 if (Utilities.noString(parentType)) 1548 t = parent; 1549 else { 1550 t = parent.predicate("fhir:"+parentType+'.'+name); 1551 } 1552 composeBackboneElement(t, "reaction", name, element, index); 1553 if (element.hasSubstance()) 1554 composeCodeableConcept(t, "AllergyIntolerance", "substance", element.getSubstance(), -1); 1555 for (int i = 0; i < element.getManifestation().size(); i++) 1556 composeCodeableConcept(t, "AllergyIntolerance", "manifestation", element.getManifestation().get(i), i); 1557 if (element.hasDescriptionElement()) 1558 composeString(t, "AllergyIntolerance", "description", element.getDescriptionElement(), -1); 1559 if (element.hasOnsetElement()) 1560 composeDateTime(t, "AllergyIntolerance", "onset", element.getOnsetElement(), -1); 1561 if (element.hasSeverityElement()) 1562 composeEnum(t, "AllergyIntolerance", "severity", element.getSeverityElement(), -1); 1563 if (element.hasExposureRoute()) 1564 composeCodeableConcept(t, "AllergyIntolerance", "exposureRoute", element.getExposureRoute(), -1); 1565 for (int i = 0; i < element.getNote().size(); i++) 1566 composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i); 1567 } 1568 1569 protected void composeAppointment(Complex parent, String parentType, String name, Appointment element, int index) { 1570 if (element == null) 1571 return; 1572 Complex t; 1573 if (Utilities.noString(parentType)) 1574 t = parent; 1575 else { 1576 t = parent.predicate("fhir:"+parentType+'.'+name); 1577 } 1578 composeDomainResource(t, "Appointment", name, element, index); 1579 for (int i = 0; i < element.getIdentifier().size(); i++) 1580 composeIdentifier(t, "Appointment", "identifier", element.getIdentifier().get(i), i); 1581 if (element.hasStatusElement()) 1582 composeEnum(t, "Appointment", "status", element.getStatusElement(), -1); 1583 if (element.hasServiceCategory()) 1584 composeCodeableConcept(t, "Appointment", "serviceCategory", element.getServiceCategory(), -1); 1585 for (int i = 0; i < element.getServiceType().size(); i++) 1586 composeCodeableConcept(t, "Appointment", "serviceType", element.getServiceType().get(i), i); 1587 for (int i = 0; i < element.getSpecialty().size(); i++) 1588 composeCodeableConcept(t, "Appointment", "specialty", element.getSpecialty().get(i), i); 1589 if (element.hasAppointmentType()) 1590 composeCodeableConcept(t, "Appointment", "appointmentType", element.getAppointmentType(), -1); 1591 for (int i = 0; i < element.getReason().size(); i++) 1592 composeCodeableConcept(t, "Appointment", "reason", element.getReason().get(i), i); 1593 for (int i = 0; i < element.getIndication().size(); i++) 1594 composeReference(t, "Appointment", "indication", element.getIndication().get(i), i); 1595 if (element.hasPriorityElement()) 1596 composeUnsignedInt(t, "Appointment", "priority", element.getPriorityElement(), -1); 1597 if (element.hasDescriptionElement()) 1598 composeString(t, "Appointment", "description", element.getDescriptionElement(), -1); 1599 for (int i = 0; i < element.getSupportingInformation().size(); i++) 1600 composeReference(t, "Appointment", "supportingInformation", element.getSupportingInformation().get(i), i); 1601 if (element.hasStartElement()) 1602 composeInstant(t, "Appointment", "start", element.getStartElement(), -1); 1603 if (element.hasEndElement()) 1604 composeInstant(t, "Appointment", "end", element.getEndElement(), -1); 1605 if (element.hasMinutesDurationElement()) 1606 composePositiveInt(t, "Appointment", "minutesDuration", element.getMinutesDurationElement(), -1); 1607 for (int i = 0; i < element.getSlot().size(); i++) 1608 composeReference(t, "Appointment", "slot", element.getSlot().get(i), i); 1609 if (element.hasCreatedElement()) 1610 composeDateTime(t, "Appointment", "created", element.getCreatedElement(), -1); 1611 if (element.hasCommentElement()) 1612 composeString(t, "Appointment", "comment", element.getCommentElement(), -1); 1613 for (int i = 0; i < element.getIncomingReferral().size(); i++) 1614 composeReference(t, "Appointment", "incomingReferral", element.getIncomingReferral().get(i), i); 1615 for (int i = 0; i < element.getParticipant().size(); i++) 1616 composeAppointmentAppointmentParticipantComponent(t, "Appointment", "participant", element.getParticipant().get(i), i); 1617 for (int i = 0; i < element.getRequestedPeriod().size(); i++) 1618 composePeriod(t, "Appointment", "requestedPeriod", element.getRequestedPeriod().get(i), i); 1619 } 1620 1621 protected void composeAppointmentAppointmentParticipantComponent(Complex parent, String parentType, String name, Appointment.AppointmentParticipantComponent element, int index) { 1622 if (element == null) 1623 return; 1624 Complex t; 1625 if (Utilities.noString(parentType)) 1626 t = parent; 1627 else { 1628 t = parent.predicate("fhir:"+parentType+'.'+name); 1629 } 1630 composeBackboneElement(t, "participant", name, element, index); 1631 for (int i = 0; i < element.getType().size(); i++) 1632 composeCodeableConcept(t, "Appointment", "type", element.getType().get(i), i); 1633 if (element.hasActor()) 1634 composeReference(t, "Appointment", "actor", element.getActor(), -1); 1635 if (element.hasRequiredElement()) 1636 composeEnum(t, "Appointment", "required", element.getRequiredElement(), -1); 1637 if (element.hasStatusElement()) 1638 composeEnum(t, "Appointment", "status", element.getStatusElement(), -1); 1639 } 1640 1641 protected void composeAppointmentResponse(Complex parent, String parentType, String name, AppointmentResponse element, int index) { 1642 if (element == null) 1643 return; 1644 Complex t; 1645 if (Utilities.noString(parentType)) 1646 t = parent; 1647 else { 1648 t = parent.predicate("fhir:"+parentType+'.'+name); 1649 } 1650 composeDomainResource(t, "AppointmentResponse", name, element, index); 1651 for (int i = 0; i < element.getIdentifier().size(); i++) 1652 composeIdentifier(t, "AppointmentResponse", "identifier", element.getIdentifier().get(i), i); 1653 if (element.hasAppointment()) 1654 composeReference(t, "AppointmentResponse", "appointment", element.getAppointment(), -1); 1655 if (element.hasStartElement()) 1656 composeInstant(t, "AppointmentResponse", "start", element.getStartElement(), -1); 1657 if (element.hasEndElement()) 1658 composeInstant(t, "AppointmentResponse", "end", element.getEndElement(), -1); 1659 for (int i = 0; i < element.getParticipantType().size(); i++) 1660 composeCodeableConcept(t, "AppointmentResponse", "participantType", element.getParticipantType().get(i), i); 1661 if (element.hasActor()) 1662 composeReference(t, "AppointmentResponse", "actor", element.getActor(), -1); 1663 if (element.hasParticipantStatusElement()) 1664 composeEnum(t, "AppointmentResponse", "participantStatus", element.getParticipantStatusElement(), -1); 1665 if (element.hasCommentElement()) 1666 composeString(t, "AppointmentResponse", "comment", element.getCommentElement(), -1); 1667 } 1668 1669 protected void composeAuditEvent(Complex parent, String parentType, String name, AuditEvent element, int index) { 1670 if (element == null) 1671 return; 1672 Complex t; 1673 if (Utilities.noString(parentType)) 1674 t = parent; 1675 else { 1676 t = parent.predicate("fhir:"+parentType+'.'+name); 1677 } 1678 composeDomainResource(t, "AuditEvent", name, element, index); 1679 if (element.hasType()) 1680 composeCoding(t, "AuditEvent", "type", element.getType(), -1); 1681 for (int i = 0; i < element.getSubtype().size(); i++) 1682 composeCoding(t, "AuditEvent", "subtype", element.getSubtype().get(i), i); 1683 if (element.hasActionElement()) 1684 composeEnum(t, "AuditEvent", "action", element.getActionElement(), -1); 1685 if (element.hasRecordedElement()) 1686 composeInstant(t, "AuditEvent", "recorded", element.getRecordedElement(), -1); 1687 if (element.hasOutcomeElement()) 1688 composeEnum(t, "AuditEvent", "outcome", element.getOutcomeElement(), -1); 1689 if (element.hasOutcomeDescElement()) 1690 composeString(t, "AuditEvent", "outcomeDesc", element.getOutcomeDescElement(), -1); 1691 for (int i = 0; i < element.getPurposeOfEvent().size(); i++) 1692 composeCodeableConcept(t, "AuditEvent", "purposeOfEvent", element.getPurposeOfEvent().get(i), i); 1693 for (int i = 0; i < element.getAgent().size(); i++) 1694 composeAuditEventAuditEventAgentComponent(t, "AuditEvent", "agent", element.getAgent().get(i), i); 1695 if (element.hasSource()) 1696 composeAuditEventAuditEventSourceComponent(t, "AuditEvent", "source", element.getSource(), -1); 1697 for (int i = 0; i < element.getEntity().size(); i++) 1698 composeAuditEventAuditEventEntityComponent(t, "AuditEvent", "entity", element.getEntity().get(i), i); 1699 } 1700 1701 protected void composeAuditEventAuditEventAgentComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentComponent 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:"+parentType+'.'+name); 1709 } 1710 composeBackboneElement(t, "agent", name, element, index); 1711 for (int i = 0; i < element.getRole().size(); i++) 1712 composeCodeableConcept(t, "AuditEvent", "role", element.getRole().get(i), i); 1713 if (element.hasReference()) 1714 composeReference(t, "AuditEvent", "reference", element.getReference(), -1); 1715 if (element.hasUserId()) 1716 composeIdentifier(t, "AuditEvent", "userId", element.getUserId(), -1); 1717 if (element.hasAltIdElement()) 1718 composeString(t, "AuditEvent", "altId", element.getAltIdElement(), -1); 1719 if (element.hasNameElement()) 1720 composeString(t, "AuditEvent", "name", element.getNameElement(), -1); 1721 if (element.hasRequestorElement()) 1722 composeBoolean(t, "AuditEvent", "requestor", element.getRequestorElement(), -1); 1723 if (element.hasLocation()) 1724 composeReference(t, "AuditEvent", "location", element.getLocation(), -1); 1725 for (int i = 0; i < element.getPolicy().size(); i++) 1726 composeUri(t, "AuditEvent", "policy", element.getPolicy().get(i), i); 1727 if (element.hasMedia()) 1728 composeCoding(t, "AuditEvent", "media", element.getMedia(), -1); 1729 if (element.hasNetwork()) 1730 composeAuditEventAuditEventAgentNetworkComponent(t, "AuditEvent", "network", element.getNetwork(), -1); 1731 for (int i = 0; i < element.getPurposeOfUse().size(); i++) 1732 composeCodeableConcept(t, "AuditEvent", "purposeOfUse", element.getPurposeOfUse().get(i), i); 1733 } 1734 1735 protected void composeAuditEventAuditEventAgentNetworkComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentNetworkComponent element, int index) { 1736 if (element == null) 1737 return; 1738 Complex t; 1739 if (Utilities.noString(parentType)) 1740 t = parent; 1741 else { 1742 t = parent.predicate("fhir:"+parentType+'.'+name); 1743 } 1744 composeBackboneElement(t, "network", name, element, index); 1745 if (element.hasAddressElement()) 1746 composeString(t, "AuditEvent", "address", element.getAddressElement(), -1); 1747 if (element.hasTypeElement()) 1748 composeEnum(t, "AuditEvent", "type", element.getTypeElement(), -1); 1749 } 1750 1751 protected void composeAuditEventAuditEventSourceComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventSourceComponent element, int index) { 1752 if (element == null) 1753 return; 1754 Complex t; 1755 if (Utilities.noString(parentType)) 1756 t = parent; 1757 else { 1758 t = parent.predicate("fhir:"+parentType+'.'+name); 1759 } 1760 composeBackboneElement(t, "source", name, element, index); 1761 if (element.hasSiteElement()) 1762 composeString(t, "AuditEvent", "site", element.getSiteElement(), -1); 1763 if (element.hasIdentifier()) 1764 composeIdentifier(t, "AuditEvent", "identifier", element.getIdentifier(), -1); 1765 for (int i = 0; i < element.getType().size(); i++) 1766 composeCoding(t, "AuditEvent", "type", element.getType().get(i), i); 1767 } 1768 1769 protected void composeAuditEventAuditEventEntityComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityComponent element, int index) { 1770 if (element == null) 1771 return; 1772 Complex t; 1773 if (Utilities.noString(parentType)) 1774 t = parent; 1775 else { 1776 t = parent.predicate("fhir:"+parentType+'.'+name); 1777 } 1778 composeBackboneElement(t, "entity", name, element, index); 1779 if (element.hasIdentifier()) 1780 composeIdentifier(t, "AuditEvent", "identifier", element.getIdentifier(), -1); 1781 if (element.hasReference()) 1782 composeReference(t, "AuditEvent", "reference", element.getReference(), -1); 1783 if (element.hasType()) 1784 composeCoding(t, "AuditEvent", "type", element.getType(), -1); 1785 if (element.hasRole()) 1786 composeCoding(t, "AuditEvent", "role", element.getRole(), -1); 1787 if (element.hasLifecycle()) 1788 composeCoding(t, "AuditEvent", "lifecycle", element.getLifecycle(), -1); 1789 for (int i = 0; i < element.getSecurityLabel().size(); i++) 1790 composeCoding(t, "AuditEvent", "securityLabel", element.getSecurityLabel().get(i), i); 1791 if (element.hasNameElement()) 1792 composeString(t, "AuditEvent", "name", element.getNameElement(), -1); 1793 if (element.hasDescriptionElement()) 1794 composeString(t, "AuditEvent", "description", element.getDescriptionElement(), -1); 1795 if (element.hasQueryElement()) 1796 composeBase64Binary(t, "AuditEvent", "query", element.getQueryElement(), -1); 1797 for (int i = 0; i < element.getDetail().size(); i++) 1798 composeAuditEventAuditEventEntityDetailComponent(t, "AuditEvent", "detail", element.getDetail().get(i), i); 1799 } 1800 1801 protected void composeAuditEventAuditEventEntityDetailComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityDetailComponent element, int index) { 1802 if (element == null) 1803 return; 1804 Complex t; 1805 if (Utilities.noString(parentType)) 1806 t = parent; 1807 else { 1808 t = parent.predicate("fhir:"+parentType+'.'+name); 1809 } 1810 composeBackboneElement(t, "detail", name, element, index); 1811 if (element.hasTypeElement()) 1812 composeString(t, "AuditEvent", "type", element.getTypeElement(), -1); 1813 if (element.hasValueElement()) 1814 composeBase64Binary(t, "AuditEvent", "value", element.getValueElement(), -1); 1815 } 1816 1817 protected void composeBasic(Complex parent, String parentType, String name, Basic element, int index) { 1818 if (element == null) 1819 return; 1820 Complex t; 1821 if (Utilities.noString(parentType)) 1822 t = parent; 1823 else { 1824 t = parent.predicate("fhir:"+parentType+'.'+name); 1825 } 1826 composeDomainResource(t, "Basic", name, element, index); 1827 for (int i = 0; i < element.getIdentifier().size(); i++) 1828 composeIdentifier(t, "Basic", "identifier", element.getIdentifier().get(i), i); 1829 if (element.hasCode()) 1830 composeCodeableConcept(t, "Basic", "code", element.getCode(), -1); 1831 if (element.hasSubject()) 1832 composeReference(t, "Basic", "subject", element.getSubject(), -1); 1833 if (element.hasCreatedElement()) 1834 composeDate(t, "Basic", "created", element.getCreatedElement(), -1); 1835 if (element.hasAuthor()) 1836 composeReference(t, "Basic", "author", element.getAuthor(), -1); 1837 } 1838 1839 protected void composeBinary(Complex parent, String parentType, String name, Binary element, int index) { 1840 if (element == null) 1841 return; 1842 Complex t; 1843 if (Utilities.noString(parentType)) 1844 t = parent; 1845 else { 1846 t = parent.predicate("fhir:"+parentType+'.'+name); 1847 } 1848 composeResource(t, "Binary", name, element, index); 1849 if (element.hasContentTypeElement()) 1850 composeCode(t, "Binary", "contentType", element.getContentTypeElement(), -1); 1851 if (element.hasSecurityContext()) 1852 composeReference(t, "Binary", "securityContext", element.getSecurityContext(), -1); 1853 if (element.hasContentElement()) 1854 composeBase64Binary(t, "Binary", "content", element.getContentElement(), -1); 1855 } 1856 1857 protected void composeBodySite(Complex parent, String parentType, String name, BodySite element, int index) { 1858 if (element == null) 1859 return; 1860 Complex t; 1861 if (Utilities.noString(parentType)) 1862 t = parent; 1863 else { 1864 t = parent.predicate("fhir:"+parentType+'.'+name); 1865 } 1866 composeDomainResource(t, "BodySite", name, element, index); 1867 for (int i = 0; i < element.getIdentifier().size(); i++) 1868 composeIdentifier(t, "BodySite", "identifier", element.getIdentifier().get(i), i); 1869 if (element.hasActiveElement()) 1870 composeBoolean(t, "BodySite", "active", element.getActiveElement(), -1); 1871 if (element.hasCode()) 1872 composeCodeableConcept(t, "BodySite", "code", element.getCode(), -1); 1873 for (int i = 0; i < element.getQualifier().size(); i++) 1874 composeCodeableConcept(t, "BodySite", "qualifier", element.getQualifier().get(i), i); 1875 if (element.hasDescriptionElement()) 1876 composeString(t, "BodySite", "description", element.getDescriptionElement(), -1); 1877 for (int i = 0; i < element.getImage().size(); i++) 1878 composeAttachment(t, "BodySite", "image", element.getImage().get(i), i); 1879 if (element.hasPatient()) 1880 composeReference(t, "BodySite", "patient", element.getPatient(), -1); 1881 } 1882 1883 protected void composeBundle(Complex parent, String parentType, String name, Bundle element, int index) { 1884 if (element == null) 1885 return; 1886 Complex t; 1887 if (Utilities.noString(parentType)) 1888 t = parent; 1889 else { 1890 t = parent.predicate("fhir:"+parentType+'.'+name); 1891 } 1892 composeResource(t, "Bundle", name, element, index); 1893 if (element.hasIdentifier()) 1894 composeIdentifier(t, "Bundle", "identifier", element.getIdentifier(), -1); 1895 if (element.hasTypeElement()) 1896 composeEnum(t, "Bundle", "type", element.getTypeElement(), -1); 1897 if (element.hasTotalElement()) 1898 composeUnsignedInt(t, "Bundle", "total", element.getTotalElement(), -1); 1899 for (int i = 0; i < element.getLink().size(); i++) 1900 composeBundleBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i); 1901 for (int i = 0; i < element.getEntry().size(); i++) 1902 composeBundleBundleEntryComponent(t, "Bundle", "entry", element.getEntry().get(i), i); 1903 if (element.hasSignature()) 1904 composeSignature(t, "Bundle", "signature", element.getSignature(), -1); 1905 } 1906 1907 protected void composeBundleBundleLinkComponent(Complex parent, String parentType, String name, Bundle.BundleLinkComponent element, int index) { 1908 if (element == null) 1909 return; 1910 Complex t; 1911 if (Utilities.noString(parentType)) 1912 t = parent; 1913 else { 1914 t = parent.predicate("fhir:"+parentType+'.'+name); 1915 } 1916 composeBackboneElement(t, "link", name, element, index); 1917 if (element.hasRelationElement()) 1918 composeString(t, "Bundle", "relation", element.getRelationElement(), -1); 1919 if (element.hasUrlElement()) 1920 composeUri(t, "Bundle", "url", element.getUrlElement(), -1); 1921 } 1922 1923 protected void composeBundleBundleEntryComponent(Complex parent, String parentType, String name, Bundle.BundleEntryComponent element, int index) { 1924 if (element == null) 1925 return; 1926 Complex t; 1927 if (Utilities.noString(parentType)) 1928 t = parent; 1929 else { 1930 t = parent.predicate("fhir:"+parentType+'.'+name); 1931 } 1932 composeBackboneElement(t, "entry", name, element, index); 1933 for (int i = 0; i < element.getLink().size(); i++) 1934 composeBundleBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i); 1935 if (element.hasFullUrlElement()) 1936 composeUri(t, "Bundle", "fullUrl", element.getFullUrlElement(), -1); 1937 if (element.hasResource()) 1938 composeResource(t, "Bundle", "resource", element.getResource(), -1); 1939 if (element.hasSearch()) 1940 composeBundleBundleEntrySearchComponent(t, "Bundle", "search", element.getSearch(), -1); 1941 if (element.hasRequest()) 1942 composeBundleBundleEntryRequestComponent(t, "Bundle", "request", element.getRequest(), -1); 1943 if (element.hasResponse()) 1944 composeBundleBundleEntryResponseComponent(t, "Bundle", "response", element.getResponse(), -1); 1945 } 1946 1947 protected void composeBundleBundleEntrySearchComponent(Complex parent, String parentType, String name, Bundle.BundleEntrySearchComponent element, int index) { 1948 if (element == null) 1949 return; 1950 Complex t; 1951 if (Utilities.noString(parentType)) 1952 t = parent; 1953 else { 1954 t = parent.predicate("fhir:"+parentType+'.'+name); 1955 } 1956 composeBackboneElement(t, "search", name, element, index); 1957 if (element.hasModeElement()) 1958 composeEnum(t, "Bundle", "mode", element.getModeElement(), -1); 1959 if (element.hasScoreElement()) 1960 composeDecimal(t, "Bundle", "score", element.getScoreElement(), -1); 1961 } 1962 1963 protected void composeBundleBundleEntryRequestComponent(Complex parent, String parentType, String name, Bundle.BundleEntryRequestComponent element, int index) { 1964 if (element == null) 1965 return; 1966 Complex t; 1967 if (Utilities.noString(parentType)) 1968 t = parent; 1969 else { 1970 t = parent.predicate("fhir:"+parentType+'.'+name); 1971 } 1972 composeBackboneElement(t, "request", name, element, index); 1973 if (element.hasMethodElement()) 1974 composeEnum(t, "Bundle", "method", element.getMethodElement(), -1); 1975 if (element.hasUrlElement()) 1976 composeUri(t, "Bundle", "url", element.getUrlElement(), -1); 1977 if (element.hasIfNoneMatchElement()) 1978 composeString(t, "Bundle", "ifNoneMatch", element.getIfNoneMatchElement(), -1); 1979 if (element.hasIfModifiedSinceElement()) 1980 composeInstant(t, "Bundle", "ifModifiedSince", element.getIfModifiedSinceElement(), -1); 1981 if (element.hasIfMatchElement()) 1982 composeString(t, "Bundle", "ifMatch", element.getIfMatchElement(), -1); 1983 if (element.hasIfNoneExistElement()) 1984 composeString(t, "Bundle", "ifNoneExist", element.getIfNoneExistElement(), -1); 1985 } 1986 1987 protected void composeBundleBundleEntryResponseComponent(Complex parent, String parentType, String name, Bundle.BundleEntryResponseComponent element, int index) { 1988 if (element == null) 1989 return; 1990 Complex t; 1991 if (Utilities.noString(parentType)) 1992 t = parent; 1993 else { 1994 t = parent.predicate("fhir:"+parentType+'.'+name); 1995 } 1996 composeBackboneElement(t, "response", name, element, index); 1997 if (element.hasStatusElement()) 1998 composeString(t, "Bundle", "status", element.getStatusElement(), -1); 1999 if (element.hasLocationElement()) 2000 composeUri(t, "Bundle", "location", element.getLocationElement(), -1); 2001 if (element.hasEtagElement()) 2002 composeString(t, "Bundle", "etag", element.getEtagElement(), -1); 2003 if (element.hasLastModifiedElement()) 2004 composeInstant(t, "Bundle", "lastModified", element.getLastModifiedElement(), -1); 2005 if (element.hasOutcome()) 2006 composeResource(t, "Bundle", "outcome", element.getOutcome(), -1); 2007 } 2008 2009 protected void composeCapabilityStatement(Complex parent, String parentType, String name, CapabilityStatement element, int index) { 2010 if (element == null) 2011 return; 2012 Complex t; 2013 if (Utilities.noString(parentType)) 2014 t = parent; 2015 else { 2016 t = parent.predicate("fhir:"+parentType+'.'+name); 2017 } 2018 composeDomainResource(t, "CapabilityStatement", name, element, index); 2019 if (element.hasUrlElement()) 2020 composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1); 2021 if (element.hasVersionElement()) 2022 composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1); 2023 if (element.hasNameElement()) 2024 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2025 if (element.hasTitleElement()) 2026 composeString(t, "CapabilityStatement", "title", element.getTitleElement(), -1); 2027 if (element.hasStatusElement()) 2028 composeEnum(t, "CapabilityStatement", "status", element.getStatusElement(), -1); 2029 if (element.hasExperimentalElement()) 2030 composeBoolean(t, "CapabilityStatement", "experimental", element.getExperimentalElement(), -1); 2031 if (element.hasDateElement()) 2032 composeDateTime(t, "CapabilityStatement", "date", element.getDateElement(), -1); 2033 if (element.hasPublisherElement()) 2034 composeString(t, "CapabilityStatement", "publisher", element.getPublisherElement(), -1); 2035 for (int i = 0; i < element.getContact().size(); i++) 2036 composeContactDetail(t, "CapabilityStatement", "contact", element.getContact().get(i), i); 2037 if (element.hasDescriptionElement()) 2038 composeMarkdown(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1); 2039 for (int i = 0; i < element.getUseContext().size(); i++) 2040 composeUsageContext(t, "CapabilityStatement", "useContext", element.getUseContext().get(i), i); 2041 for (int i = 0; i < element.getJurisdiction().size(); i++) 2042 composeCodeableConcept(t, "CapabilityStatement", "jurisdiction", element.getJurisdiction().get(i), i); 2043 if (element.hasPurposeElement()) 2044 composeMarkdown(t, "CapabilityStatement", "purpose", element.getPurposeElement(), -1); 2045 if (element.hasCopyrightElement()) 2046 composeMarkdown(t, "CapabilityStatement", "copyright", element.getCopyrightElement(), -1); 2047 if (element.hasKindElement()) 2048 composeEnum(t, "CapabilityStatement", "kind", element.getKindElement(), -1); 2049 for (int i = 0; i < element.getInstantiates().size(); i++) 2050 composeUri(t, "CapabilityStatement", "instantiates", element.getInstantiates().get(i), i); 2051 if (element.hasSoftware()) 2052 composeCapabilityStatementCapabilityStatementSoftwareComponent(t, "CapabilityStatement", "software", element.getSoftware(), -1); 2053 if (element.hasImplementation()) 2054 composeCapabilityStatementCapabilityStatementImplementationComponent(t, "CapabilityStatement", "implementation", element.getImplementation(), -1); 2055 if (element.hasFhirVersionElement()) 2056 composeId(t, "CapabilityStatement", "fhirVersion", element.getFhirVersionElement(), -1); 2057 if (element.hasAcceptUnknownElement()) 2058 composeEnum(t, "CapabilityStatement", "acceptUnknown", element.getAcceptUnknownElement(), -1); 2059 for (int i = 0; i < element.getFormat().size(); i++) 2060 composeCode(t, "CapabilityStatement", "format", element.getFormat().get(i), i); 2061 for (int i = 0; i < element.getPatchFormat().size(); i++) 2062 composeCode(t, "CapabilityStatement", "patchFormat", element.getPatchFormat().get(i), i); 2063 for (int i = 0; i < element.getImplementationGuide().size(); i++) 2064 composeUri(t, "CapabilityStatement", "implementationGuide", element.getImplementationGuide().get(i), i); 2065 for (int i = 0; i < element.getProfile().size(); i++) 2066 composeReference(t, "CapabilityStatement", "profile", element.getProfile().get(i), i); 2067 for (int i = 0; i < element.getRest().size(); i++) 2068 composeCapabilityStatementCapabilityStatementRestComponent(t, "CapabilityStatement", "rest", element.getRest().get(i), i); 2069 for (int i = 0; i < element.getMessaging().size(); i++) 2070 composeCapabilityStatementCapabilityStatementMessagingComponent(t, "CapabilityStatement", "messaging", element.getMessaging().get(i), i); 2071 for (int i = 0; i < element.getDocument().size(); i++) 2072 composeCapabilityStatementCapabilityStatementDocumentComponent(t, "CapabilityStatement", "document", element.getDocument().get(i), i); 2073 } 2074 2075 protected void composeCapabilityStatementCapabilityStatementSoftwareComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementSoftwareComponent element, int index) { 2076 if (element == null) 2077 return; 2078 Complex t; 2079 if (Utilities.noString(parentType)) 2080 t = parent; 2081 else { 2082 t = parent.predicate("fhir:"+parentType+'.'+name); 2083 } 2084 composeBackboneElement(t, "software", name, element, index); 2085 if (element.hasNameElement()) 2086 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2087 if (element.hasVersionElement()) 2088 composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1); 2089 if (element.hasReleaseDateElement()) 2090 composeDateTime(t, "CapabilityStatement", "releaseDate", element.getReleaseDateElement(), -1); 2091 } 2092 2093 protected void composeCapabilityStatementCapabilityStatementImplementationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementImplementationComponent element, int index) { 2094 if (element == null) 2095 return; 2096 Complex t; 2097 if (Utilities.noString(parentType)) 2098 t = parent; 2099 else { 2100 t = parent.predicate("fhir:"+parentType+'.'+name); 2101 } 2102 composeBackboneElement(t, "implementation", name, element, index); 2103 if (element.hasDescriptionElement()) 2104 composeString(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1); 2105 if (element.hasUrlElement()) 2106 composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1); 2107 } 2108 2109 protected void composeCapabilityStatementCapabilityStatementRestComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestComponent element, int index) { 2110 if (element == null) 2111 return; 2112 Complex t; 2113 if (Utilities.noString(parentType)) 2114 t = parent; 2115 else { 2116 t = parent.predicate("fhir:"+parentType+'.'+name); 2117 } 2118 composeBackboneElement(t, "rest", name, element, index); 2119 if (element.hasModeElement()) 2120 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2121 if (element.hasDocumentationElement()) 2122 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2123 if (element.hasSecurity()) 2124 composeCapabilityStatementCapabilityStatementRestSecurityComponent(t, "CapabilityStatement", "security", element.getSecurity(), -1); 2125 for (int i = 0; i < element.getResource().size(); i++) 2126 composeCapabilityStatementCapabilityStatementRestResourceComponent(t, "CapabilityStatement", "resource", element.getResource().get(i), i); 2127 for (int i = 0; i < element.getInteraction().size(); i++) 2128 composeCapabilityStatementSystemInteractionComponent(t, "CapabilityStatement", "interaction", element.getInteraction().get(i), i); 2129 for (int i = 0; i < element.getSearchParam().size(); i++) 2130 composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatement", "searchParam", element.getSearchParam().get(i), i); 2131 for (int i = 0; i < element.getOperation().size(); i++) 2132 composeCapabilityStatementCapabilityStatementRestOperationComponent(t, "CapabilityStatement", "operation", element.getOperation().get(i), i); 2133 for (int i = 0; i < element.getCompartment().size(); i++) 2134 composeUri(t, "CapabilityStatement", "compartment", element.getCompartment().get(i), i); 2135 } 2136 2137 protected void composeCapabilityStatementCapabilityStatementRestSecurityComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityComponent 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:"+parentType+'.'+name); 2145 } 2146 composeBackboneElement(t, "security", name, element, index); 2147 if (element.hasCorsElement()) 2148 composeBoolean(t, "CapabilityStatement", "cors", element.getCorsElement(), -1); 2149 for (int i = 0; i < element.getService().size(); i++) 2150 composeCodeableConcept(t, "CapabilityStatement", "service", element.getService().get(i), i); 2151 if (element.hasDescriptionElement()) 2152 composeString(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1); 2153 for (int i = 0; i < element.getCertificate().size(); i++) 2154 composeCapabilityStatementCapabilityStatementRestSecurityCertificateComponent(t, "CapabilityStatement", "certificate", element.getCertificate().get(i), i); 2155 } 2156 2157 protected void composeCapabilityStatementCapabilityStatementRestSecurityCertificateComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityCertificateComponent element, int index) { 2158 if (element == null) 2159 return; 2160 Complex t; 2161 if (Utilities.noString(parentType)) 2162 t = parent; 2163 else { 2164 t = parent.predicate("fhir:"+parentType+'.'+name); 2165 } 2166 composeBackboneElement(t, "certificate", name, element, index); 2167 if (element.hasTypeElement()) 2168 composeCode(t, "CapabilityStatement", "type", element.getTypeElement(), -1); 2169 if (element.hasBlobElement()) 2170 composeBase64Binary(t, "CapabilityStatement", "blob", element.getBlobElement(), -1); 2171 } 2172 2173 protected void composeCapabilityStatementCapabilityStatementRestResourceComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceComponent element, int index) { 2174 if (element == null) 2175 return; 2176 Complex t; 2177 if (Utilities.noString(parentType)) 2178 t = parent; 2179 else { 2180 t = parent.predicate("fhir:"+parentType+'.'+name); 2181 } 2182 composeBackboneElement(t, "resource", name, element, index); 2183 if (element.hasTypeElement()) 2184 composeCode(t, "CapabilityStatement", "type", element.getTypeElement(), -1); 2185 if (element.hasProfile()) 2186 composeReference(t, "CapabilityStatement", "profile", element.getProfile(), -1); 2187 if (element.hasDocumentationElement()) 2188 composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2189 for (int i = 0; i < element.getInteraction().size(); i++) 2190 composeCapabilityStatementResourceInteractionComponent(t, "CapabilityStatement", "interaction", element.getInteraction().get(i), i); 2191 if (element.hasVersioningElement()) 2192 composeEnum(t, "CapabilityStatement", "versioning", element.getVersioningElement(), -1); 2193 if (element.hasReadHistoryElement()) 2194 composeBoolean(t, "CapabilityStatement", "readHistory", element.getReadHistoryElement(), -1); 2195 if (element.hasUpdateCreateElement()) 2196 composeBoolean(t, "CapabilityStatement", "updateCreate", element.getUpdateCreateElement(), -1); 2197 if (element.hasConditionalCreateElement()) 2198 composeBoolean(t, "CapabilityStatement", "conditionalCreate", element.getConditionalCreateElement(), -1); 2199 if (element.hasConditionalReadElement()) 2200 composeEnum(t, "CapabilityStatement", "conditionalRead", element.getConditionalReadElement(), -1); 2201 if (element.hasConditionalUpdateElement()) 2202 composeBoolean(t, "CapabilityStatement", "conditionalUpdate", element.getConditionalUpdateElement(), -1); 2203 if (element.hasConditionalDeleteElement()) 2204 composeEnum(t, "CapabilityStatement", "conditionalDelete", element.getConditionalDeleteElement(), -1); 2205 for (int i = 0; i < element.getReferencePolicy().size(); i++) 2206 composeEnum(t, "CapabilityStatement", "referencePolicy", element.getReferencePolicy().get(i), i); 2207 for (int i = 0; i < element.getSearchInclude().size(); i++) 2208 composeString(t, "CapabilityStatement", "searchInclude", element.getSearchInclude().get(i), i); 2209 for (int i = 0; i < element.getSearchRevInclude().size(); i++) 2210 composeString(t, "CapabilityStatement", "searchRevInclude", element.getSearchRevInclude().get(i), i); 2211 for (int i = 0; i < element.getSearchParam().size(); i++) 2212 composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatement", "searchParam", element.getSearchParam().get(i), i); 2213 } 2214 2215 protected void composeCapabilityStatementResourceInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.ResourceInteractionComponent element, int index) { 2216 if (element == null) 2217 return; 2218 Complex t; 2219 if (Utilities.noString(parentType)) 2220 t = parent; 2221 else { 2222 t = parent.predicate("fhir:"+parentType+'.'+name); 2223 } 2224 composeBackboneElement(t, "interaction", name, element, index); 2225 if (element.hasCodeElement()) 2226 composeEnum(t, "CapabilityStatement", "code", element.getCodeElement(), -1); 2227 if (element.hasDocumentationElement()) 2228 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2229 } 2230 2231 protected void composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent element, int index) { 2232 if (element == null) 2233 return; 2234 Complex t; 2235 if (Utilities.noString(parentType)) 2236 t = parent; 2237 else { 2238 t = parent.predicate("fhir:"+parentType+'.'+name); 2239 } 2240 composeBackboneElement(t, "searchParam", name, element, index); 2241 if (element.hasNameElement()) 2242 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2243 if (element.hasDefinitionElement()) 2244 composeUri(t, "CapabilityStatement", "definition", element.getDefinitionElement(), -1); 2245 if (element.hasTypeElement()) 2246 composeEnum(t, "CapabilityStatement", "type", element.getTypeElement(), -1); 2247 if (element.hasDocumentationElement()) 2248 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2249 } 2250 2251 protected void composeCapabilityStatementSystemInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.SystemInteractionComponent element, int index) { 2252 if (element == null) 2253 return; 2254 Complex t; 2255 if (Utilities.noString(parentType)) 2256 t = parent; 2257 else { 2258 t = parent.predicate("fhir:"+parentType+'.'+name); 2259 } 2260 composeBackboneElement(t, "interaction", name, element, index); 2261 if (element.hasCodeElement()) 2262 composeEnum(t, "CapabilityStatement", "code", element.getCodeElement(), -1); 2263 if (element.hasDocumentationElement()) 2264 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2265 } 2266 2267 protected void composeCapabilityStatementCapabilityStatementRestOperationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestOperationComponent element, int index) { 2268 if (element == null) 2269 return; 2270 Complex t; 2271 if (Utilities.noString(parentType)) 2272 t = parent; 2273 else { 2274 t = parent.predicate("fhir:"+parentType+'.'+name); 2275 } 2276 composeBackboneElement(t, "operation", name, element, index); 2277 if (element.hasNameElement()) 2278 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2279 if (element.hasDefinition()) 2280 composeReference(t, "CapabilityStatement", "definition", element.getDefinition(), -1); 2281 } 2282 2283 protected void composeCapabilityStatementCapabilityStatementMessagingComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingComponent element, int index) { 2284 if (element == null) 2285 return; 2286 Complex t; 2287 if (Utilities.noString(parentType)) 2288 t = parent; 2289 else { 2290 t = parent.predicate("fhir:"+parentType+'.'+name); 2291 } 2292 composeBackboneElement(t, "messaging", name, element, index); 2293 for (int i = 0; i < element.getEndpoint().size(); i++) 2294 composeCapabilityStatementCapabilityStatementMessagingEndpointComponent(t, "CapabilityStatement", "endpoint", element.getEndpoint().get(i), i); 2295 if (element.hasReliableCacheElement()) 2296 composeUnsignedInt(t, "CapabilityStatement", "reliableCache", element.getReliableCacheElement(), -1); 2297 if (element.hasDocumentationElement()) 2298 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2299 for (int i = 0; i < element.getSupportedMessage().size(); i++) 2300 composeCapabilityStatementCapabilityStatementMessagingSupportedMessageComponent(t, "CapabilityStatement", "supportedMessage", element.getSupportedMessage().get(i), i); 2301 for (int i = 0; i < element.getEvent().size(); i++) 2302 composeCapabilityStatementCapabilityStatementMessagingEventComponent(t, "CapabilityStatement", "event", element.getEvent().get(i), i); 2303 } 2304 2305 protected void composeCapabilityStatementCapabilityStatementMessagingEndpointComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEndpointComponent element, int index) { 2306 if (element == null) 2307 return; 2308 Complex t; 2309 if (Utilities.noString(parentType)) 2310 t = parent; 2311 else { 2312 t = parent.predicate("fhir:"+parentType+'.'+name); 2313 } 2314 composeBackboneElement(t, "endpoint", name, element, index); 2315 if (element.hasProtocol()) 2316 composeCoding(t, "CapabilityStatement", "protocol", element.getProtocol(), -1); 2317 if (element.hasAddressElement()) 2318 composeUri(t, "CapabilityStatement", "address", element.getAddressElement(), -1); 2319 } 2320 2321 protected void composeCapabilityStatementCapabilityStatementMessagingSupportedMessageComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent element, int index) { 2322 if (element == null) 2323 return; 2324 Complex t; 2325 if (Utilities.noString(parentType)) 2326 t = parent; 2327 else { 2328 t = parent.predicate("fhir:"+parentType+'.'+name); 2329 } 2330 composeBackboneElement(t, "supportedMessage", name, element, index); 2331 if (element.hasModeElement()) 2332 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2333 if (element.hasDefinition()) 2334 composeReference(t, "CapabilityStatement", "definition", element.getDefinition(), -1); 2335 } 2336 2337 protected void composeCapabilityStatementCapabilityStatementMessagingEventComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEventComponent element, int index) { 2338 if (element == null) 2339 return; 2340 Complex t; 2341 if (Utilities.noString(parentType)) 2342 t = parent; 2343 else { 2344 t = parent.predicate("fhir:"+parentType+'.'+name); 2345 } 2346 composeBackboneElement(t, "event", name, element, index); 2347 if (element.hasCode()) 2348 composeCoding(t, "CapabilityStatement", "code", element.getCode(), -1); 2349 if (element.hasCategoryElement()) 2350 composeEnum(t, "CapabilityStatement", "category", element.getCategoryElement(), -1); 2351 if (element.hasModeElement()) 2352 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2353 if (element.hasFocusElement()) 2354 composeCode(t, "CapabilityStatement", "focus", element.getFocusElement(), -1); 2355 if (element.hasRequest()) 2356 composeReference(t, "CapabilityStatement", "request", element.getRequest(), -1); 2357 if (element.hasResponse()) 2358 composeReference(t, "CapabilityStatement", "response", element.getResponse(), -1); 2359 if (element.hasDocumentationElement()) 2360 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2361 } 2362 2363 protected void composeCapabilityStatementCapabilityStatementDocumentComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementDocumentComponent element, int index) { 2364 if (element == null) 2365 return; 2366 Complex t; 2367 if (Utilities.noString(parentType)) 2368 t = parent; 2369 else { 2370 t = parent.predicate("fhir:"+parentType+'.'+name); 2371 } 2372 composeBackboneElement(t, "document", name, element, index); 2373 if (element.hasModeElement()) 2374 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2375 if (element.hasDocumentationElement()) 2376 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2377 if (element.hasProfile()) 2378 composeReference(t, "CapabilityStatement", "profile", element.getProfile(), -1); 2379 } 2380 2381 protected void composeCarePlan(Complex parent, String parentType, String name, CarePlan element, int index) { 2382 if (element == null) 2383 return; 2384 Complex t; 2385 if (Utilities.noString(parentType)) 2386 t = parent; 2387 else { 2388 t = parent.predicate("fhir:"+parentType+'.'+name); 2389 } 2390 composeDomainResource(t, "CarePlan", name, element, index); 2391 for (int i = 0; i < element.getIdentifier().size(); i++) 2392 composeIdentifier(t, "CarePlan", "identifier", element.getIdentifier().get(i), i); 2393 for (int i = 0; i < element.getDefinition().size(); i++) 2394 composeReference(t, "CarePlan", "definition", element.getDefinition().get(i), i); 2395 for (int i = 0; i < element.getBasedOn().size(); i++) 2396 composeReference(t, "CarePlan", "basedOn", element.getBasedOn().get(i), i); 2397 for (int i = 0; i < element.getReplaces().size(); i++) 2398 composeReference(t, "CarePlan", "replaces", element.getReplaces().get(i), i); 2399 for (int i = 0; i < element.getPartOf().size(); i++) 2400 composeReference(t, "CarePlan", "partOf", element.getPartOf().get(i), i); 2401 if (element.hasStatusElement()) 2402 composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1); 2403 if (element.hasIntentElement()) 2404 composeEnum(t, "CarePlan", "intent", element.getIntentElement(), -1); 2405 for (int i = 0; i < element.getCategory().size(); i++) 2406 composeCodeableConcept(t, "CarePlan", "category", element.getCategory().get(i), i); 2407 if (element.hasTitleElement()) 2408 composeString(t, "CarePlan", "title", element.getTitleElement(), -1); 2409 if (element.hasDescriptionElement()) 2410 composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1); 2411 if (element.hasSubject()) 2412 composeReference(t, "CarePlan", "subject", element.getSubject(), -1); 2413 if (element.hasContext()) 2414 composeReference(t, "CarePlan", "context", element.getContext(), -1); 2415 if (element.hasPeriod()) 2416 composePeriod(t, "CarePlan", "period", element.getPeriod(), -1); 2417 for (int i = 0; i < element.getAuthor().size(); i++) 2418 composeReference(t, "CarePlan", "author", element.getAuthor().get(i), i); 2419 for (int i = 0; i < element.getCareTeam().size(); i++) 2420 composeReference(t, "CarePlan", "careTeam", element.getCareTeam().get(i), i); 2421 for (int i = 0; i < element.getAddresses().size(); i++) 2422 composeReference(t, "CarePlan", "addresses", element.getAddresses().get(i), i); 2423 for (int i = 0; i < element.getSupportingInfo().size(); i++) 2424 composeReference(t, "CarePlan", "supportingInfo", element.getSupportingInfo().get(i), i); 2425 for (int i = 0; i < element.getGoal().size(); i++) 2426 composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i); 2427 for (int i = 0; i < element.getActivity().size(); i++) 2428 composeCarePlanCarePlanActivityComponent(t, "CarePlan", "activity", element.getActivity().get(i), i); 2429 for (int i = 0; i < element.getNote().size(); i++) 2430 composeAnnotation(t, "CarePlan", "note", element.getNote().get(i), i); 2431 } 2432 2433 protected void composeCarePlanCarePlanActivityComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityComponent element, int index) { 2434 if (element == null) 2435 return; 2436 Complex t; 2437 if (Utilities.noString(parentType)) 2438 t = parent; 2439 else { 2440 t = parent.predicate("fhir:"+parentType+'.'+name); 2441 } 2442 composeBackboneElement(t, "activity", name, element, index); 2443 for (int i = 0; i < element.getOutcomeCodeableConcept().size(); i++) 2444 composeCodeableConcept(t, "CarePlan", "outcomeCodeableConcept", element.getOutcomeCodeableConcept().get(i), i); 2445 for (int i = 0; i < element.getOutcomeReference().size(); i++) 2446 composeReference(t, "CarePlan", "outcomeReference", element.getOutcomeReference().get(i), i); 2447 for (int i = 0; i < element.getProgress().size(); i++) 2448 composeAnnotation(t, "CarePlan", "progress", element.getProgress().get(i), i); 2449 if (element.hasReference()) 2450 composeReference(t, "CarePlan", "reference", element.getReference(), -1); 2451 if (element.hasDetail()) 2452 composeCarePlanCarePlanActivityDetailComponent(t, "CarePlan", "detail", element.getDetail(), -1); 2453 } 2454 2455 protected void composeCarePlanCarePlanActivityDetailComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityDetailComponent element, int index) { 2456 if (element == null) 2457 return; 2458 Complex t; 2459 if (Utilities.noString(parentType)) 2460 t = parent; 2461 else { 2462 t = parent.predicate("fhir:"+parentType+'.'+name); 2463 } 2464 composeBackboneElement(t, "detail", name, element, index); 2465 if (element.hasCategory()) 2466 composeCodeableConcept(t, "CarePlan", "category", element.getCategory(), -1); 2467 if (element.hasDefinition()) 2468 composeReference(t, "CarePlan", "definition", element.getDefinition(), -1); 2469 if (element.hasCode()) 2470 composeCodeableConcept(t, "CarePlan", "code", element.getCode(), -1); 2471 for (int i = 0; i < element.getReasonCode().size(); i++) 2472 composeCodeableConcept(t, "CarePlan", "reasonCode", element.getReasonCode().get(i), i); 2473 for (int i = 0; i < element.getReasonReference().size(); i++) 2474 composeReference(t, "CarePlan", "reasonReference", element.getReasonReference().get(i), i); 2475 for (int i = 0; i < element.getGoal().size(); i++) 2476 composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i); 2477 if (element.hasStatusElement()) 2478 composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1); 2479 if (element.hasStatusReasonElement()) 2480 composeString(t, "CarePlan", "statusReason", element.getStatusReasonElement(), -1); 2481 if (element.hasProhibitedElement()) 2482 composeBoolean(t, "CarePlan", "prohibited", element.getProhibitedElement(), -1); 2483 if (element.hasScheduled()) 2484 composeType(t, "CarePlan", "scheduled", element.getScheduled(), -1); 2485 if (element.hasLocation()) 2486 composeReference(t, "CarePlan", "location", element.getLocation(), -1); 2487 for (int i = 0; i < element.getPerformer().size(); i++) 2488 composeReference(t, "CarePlan", "performer", element.getPerformer().get(i), i); 2489 if (element.hasProduct()) 2490 composeType(t, "CarePlan", "product", element.getProduct(), -1); 2491 if (element.hasDailyAmount()) 2492 composeQuantity(t, "CarePlan", "dailyAmount", element.getDailyAmount(), -1); 2493 if (element.hasQuantity()) 2494 composeQuantity(t, "CarePlan", "quantity", element.getQuantity(), -1); 2495 if (element.hasDescriptionElement()) 2496 composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1); 2497 } 2498 2499 protected void composeCareTeam(Complex parent, String parentType, String name, CareTeam element, int index) { 2500 if (element == null) 2501 return; 2502 Complex t; 2503 if (Utilities.noString(parentType)) 2504 t = parent; 2505 else { 2506 t = parent.predicate("fhir:"+parentType+'.'+name); 2507 } 2508 composeDomainResource(t, "CareTeam", name, element, index); 2509 for (int i = 0; i < element.getIdentifier().size(); i++) 2510 composeIdentifier(t, "CareTeam", "identifier", element.getIdentifier().get(i), i); 2511 if (element.hasStatusElement()) 2512 composeEnum(t, "CareTeam", "status", element.getStatusElement(), -1); 2513 for (int i = 0; i < element.getCategory().size(); i++) 2514 composeCodeableConcept(t, "CareTeam", "category", element.getCategory().get(i), i); 2515 if (element.hasNameElement()) 2516 composeString(t, "CareTeam", "name", element.getNameElement(), -1); 2517 if (element.hasSubject()) 2518 composeReference(t, "CareTeam", "subject", element.getSubject(), -1); 2519 if (element.hasContext()) 2520 composeReference(t, "CareTeam", "context", element.getContext(), -1); 2521 if (element.hasPeriod()) 2522 composePeriod(t, "CareTeam", "period", element.getPeriod(), -1); 2523 for (int i = 0; i < element.getParticipant().size(); i++) 2524 composeCareTeamCareTeamParticipantComponent(t, "CareTeam", "participant", element.getParticipant().get(i), i); 2525 for (int i = 0; i < element.getReasonCode().size(); i++) 2526 composeCodeableConcept(t, "CareTeam", "reasonCode", element.getReasonCode().get(i), i); 2527 for (int i = 0; i < element.getReasonReference().size(); i++) 2528 composeReference(t, "CareTeam", "reasonReference", element.getReasonReference().get(i), i); 2529 for (int i = 0; i < element.getManagingOrganization().size(); i++) 2530 composeReference(t, "CareTeam", "managingOrganization", element.getManagingOrganization().get(i), i); 2531 for (int i = 0; i < element.getNote().size(); i++) 2532 composeAnnotation(t, "CareTeam", "note", element.getNote().get(i), i); 2533 } 2534 2535 protected void composeCareTeamCareTeamParticipantComponent(Complex parent, String parentType, String name, CareTeam.CareTeamParticipantComponent element, int index) { 2536 if (element == null) 2537 return; 2538 Complex t; 2539 if (Utilities.noString(parentType)) 2540 t = parent; 2541 else { 2542 t = parent.predicate("fhir:"+parentType+'.'+name); 2543 } 2544 composeBackboneElement(t, "participant", name, element, index); 2545 if (element.hasRole()) 2546 composeCodeableConcept(t, "CareTeam", "role", element.getRole(), -1); 2547 if (element.hasMember()) 2548 composeReference(t, "CareTeam", "member", element.getMember(), -1); 2549 if (element.hasOnBehalfOf()) 2550 composeReference(t, "CareTeam", "onBehalfOf", element.getOnBehalfOf(), -1); 2551 if (element.hasPeriod()) 2552 composePeriod(t, "CareTeam", "period", element.getPeriod(), -1); 2553 } 2554 2555 protected void composeChargeItem(Complex parent, String parentType, String name, ChargeItem element, int index) { 2556 if (element == null) 2557 return; 2558 Complex t; 2559 if (Utilities.noString(parentType)) 2560 t = parent; 2561 else { 2562 t = parent.predicate("fhir:"+parentType+'.'+name); 2563 } 2564 composeDomainResource(t, "ChargeItem", name, element, index); 2565 if (element.hasIdentifier()) 2566 composeIdentifier(t, "ChargeItem", "identifier", element.getIdentifier(), -1); 2567 for (int i = 0; i < element.getDefinition().size(); i++) 2568 composeUri(t, "ChargeItem", "definition", element.getDefinition().get(i), i); 2569 if (element.hasStatusElement()) 2570 composeEnum(t, "ChargeItem", "status", element.getStatusElement(), -1); 2571 for (int i = 0; i < element.getPartOf().size(); i++) 2572 composeReference(t, "ChargeItem", "partOf", element.getPartOf().get(i), i); 2573 if (element.hasCode()) 2574 composeCodeableConcept(t, "ChargeItem", "code", element.getCode(), -1); 2575 if (element.hasSubject()) 2576 composeReference(t, "ChargeItem", "subject", element.getSubject(), -1); 2577 if (element.hasContext()) 2578 composeReference(t, "ChargeItem", "context", element.getContext(), -1); 2579 if (element.hasOccurrence()) 2580 composeType(t, "ChargeItem", "occurrence", element.getOccurrence(), -1); 2581 for (int i = 0; i < element.getParticipant().size(); i++) 2582 composeChargeItemChargeItemParticipantComponent(t, "ChargeItem", "participant", element.getParticipant().get(i), i); 2583 if (element.hasPerformingOrganization()) 2584 composeReference(t, "ChargeItem", "performingOrganization", element.getPerformingOrganization(), -1); 2585 if (element.hasRequestingOrganization()) 2586 composeReference(t, "ChargeItem", "requestingOrganization", element.getRequestingOrganization(), -1); 2587 if (element.hasQuantity()) 2588 composeQuantity(t, "ChargeItem", "quantity", element.getQuantity(), -1); 2589 for (int i = 0; i < element.getBodysite().size(); i++) 2590 composeCodeableConcept(t, "ChargeItem", "bodysite", element.getBodysite().get(i), i); 2591 if (element.hasFactorOverrideElement()) 2592 composeDecimal(t, "ChargeItem", "factorOverride", element.getFactorOverrideElement(), -1); 2593 if (element.hasPriceOverride()) 2594 composeMoney(t, "ChargeItem", "priceOverride", element.getPriceOverride(), -1); 2595 if (element.hasOverrideReasonElement()) 2596 composeString(t, "ChargeItem", "overrideReason", element.getOverrideReasonElement(), -1); 2597 if (element.hasEnterer()) 2598 composeReference(t, "ChargeItem", "enterer", element.getEnterer(), -1); 2599 if (element.hasEnteredDateElement()) 2600 composeDateTime(t, "ChargeItem", "enteredDate", element.getEnteredDateElement(), -1); 2601 for (int i = 0; i < element.getReason().size(); i++) 2602 composeCodeableConcept(t, "ChargeItem", "reason", element.getReason().get(i), i); 2603 for (int i = 0; i < element.getService().size(); i++) 2604 composeReference(t, "ChargeItem", "service", element.getService().get(i), i); 2605 for (int i = 0; i < element.getAccount().size(); i++) 2606 composeReference(t, "ChargeItem", "account", element.getAccount().get(i), i); 2607 for (int i = 0; i < element.getNote().size(); i++) 2608 composeAnnotation(t, "ChargeItem", "note", element.getNote().get(i), i); 2609 for (int i = 0; i < element.getSupportingInformation().size(); i++) 2610 composeReference(t, "ChargeItem", "supportingInformation", element.getSupportingInformation().get(i), i); 2611 } 2612 2613 protected void composeChargeItemChargeItemParticipantComponent(Complex parent, String parentType, String name, ChargeItem.ChargeItemParticipantComponent element, int index) { 2614 if (element == null) 2615 return; 2616 Complex t; 2617 if (Utilities.noString(parentType)) 2618 t = parent; 2619 else { 2620 t = parent.predicate("fhir:"+parentType+'.'+name); 2621 } 2622 composeBackboneElement(t, "participant", name, element, index); 2623 if (element.hasRole()) 2624 composeCodeableConcept(t, "ChargeItem", "role", element.getRole(), -1); 2625 if (element.hasActor()) 2626 composeReference(t, "ChargeItem", "actor", element.getActor(), -1); 2627 } 2628 2629 protected void composeClaim(Complex parent, String parentType, String name, Claim element, int index) { 2630 if (element == null) 2631 return; 2632 Complex t; 2633 if (Utilities.noString(parentType)) 2634 t = parent; 2635 else { 2636 t = parent.predicate("fhir:"+parentType+'.'+name); 2637 } 2638 composeDomainResource(t, "Claim", name, element, index); 2639 for (int i = 0; i < element.getIdentifier().size(); i++) 2640 composeIdentifier(t, "Claim", "identifier", element.getIdentifier().get(i), i); 2641 if (element.hasStatusElement()) 2642 composeEnum(t, "Claim", "status", element.getStatusElement(), -1); 2643 if (element.hasType()) 2644 composeCodeableConcept(t, "Claim", "type", element.getType(), -1); 2645 for (int i = 0; i < element.getSubType().size(); i++) 2646 composeCodeableConcept(t, "Claim", "subType", element.getSubType().get(i), i); 2647 if (element.hasUseElement()) 2648 composeEnum(t, "Claim", "use", element.getUseElement(), -1); 2649 if (element.hasPatient()) 2650 composeReference(t, "Claim", "patient", element.getPatient(), -1); 2651 if (element.hasBillablePeriod()) 2652 composePeriod(t, "Claim", "billablePeriod", element.getBillablePeriod(), -1); 2653 if (element.hasCreatedElement()) 2654 composeDateTime(t, "Claim", "created", element.getCreatedElement(), -1); 2655 if (element.hasEnterer()) 2656 composeReference(t, "Claim", "enterer", element.getEnterer(), -1); 2657 if (element.hasInsurer()) 2658 composeReference(t, "Claim", "insurer", element.getInsurer(), -1); 2659 if (element.hasProvider()) 2660 composeReference(t, "Claim", "provider", element.getProvider(), -1); 2661 if (element.hasOrganization()) 2662 composeReference(t, "Claim", "organization", element.getOrganization(), -1); 2663 if (element.hasPriority()) 2664 composeCodeableConcept(t, "Claim", "priority", element.getPriority(), -1); 2665 if (element.hasFundsReserve()) 2666 composeCodeableConcept(t, "Claim", "fundsReserve", element.getFundsReserve(), -1); 2667 for (int i = 0; i < element.getRelated().size(); i++) 2668 composeClaimRelatedClaimComponent(t, "Claim", "related", element.getRelated().get(i), i); 2669 if (element.hasPrescription()) 2670 composeReference(t, "Claim", "prescription", element.getPrescription(), -1); 2671 if (element.hasOriginalPrescription()) 2672 composeReference(t, "Claim", "originalPrescription", element.getOriginalPrescription(), -1); 2673 if (element.hasPayee()) 2674 composeClaimPayeeComponent(t, "Claim", "payee", element.getPayee(), -1); 2675 if (element.hasReferral()) 2676 composeReference(t, "Claim", "referral", element.getReferral(), -1); 2677 if (element.hasFacility()) 2678 composeReference(t, "Claim", "facility", element.getFacility(), -1); 2679 for (int i = 0; i < element.getCareTeam().size(); i++) 2680 composeClaimCareTeamComponent(t, "Claim", "careTeam", element.getCareTeam().get(i), i); 2681 for (int i = 0; i < element.getInformation().size(); i++) 2682 composeClaimSpecialConditionComponent(t, "Claim", "information", element.getInformation().get(i), i); 2683 for (int i = 0; i < element.getDiagnosis().size(); i++) 2684 composeClaimDiagnosisComponent(t, "Claim", "diagnosis", element.getDiagnosis().get(i), i); 2685 for (int i = 0; i < element.getProcedure().size(); i++) 2686 composeClaimProcedureComponent(t, "Claim", "procedure", element.getProcedure().get(i), i); 2687 for (int i = 0; i < element.getInsurance().size(); i++) 2688 composeClaimInsuranceComponent(t, "Claim", "insurance", element.getInsurance().get(i), i); 2689 if (element.hasAccident()) 2690 composeClaimAccidentComponent(t, "Claim", "accident", element.getAccident(), -1); 2691 if (element.hasEmploymentImpacted()) 2692 composePeriod(t, "Claim", "employmentImpacted", element.getEmploymentImpacted(), -1); 2693 if (element.hasHospitalization()) 2694 composePeriod(t, "Claim", "hospitalization", element.getHospitalization(), -1); 2695 for (int i = 0; i < element.getItem().size(); i++) 2696 composeClaimItemComponent(t, "Claim", "item", element.getItem().get(i), i); 2697 if (element.hasTotal()) 2698 composeMoney(t, "Claim", "total", element.getTotal(), -1); 2699 } 2700 2701 protected void composeClaimRelatedClaimComponent(Complex parent, String parentType, String name, Claim.RelatedClaimComponent 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:"+parentType+'.'+name); 2709 } 2710 composeBackboneElement(t, "related", name, element, index); 2711 if (element.hasClaim()) 2712 composeReference(t, "Claim", "claim", element.getClaim(), -1); 2713 if (element.hasRelationship()) 2714 composeCodeableConcept(t, "Claim", "relationship", element.getRelationship(), -1); 2715 if (element.hasReference()) 2716 composeIdentifier(t, "Claim", "reference", element.getReference(), -1); 2717 } 2718 2719 protected void composeClaimPayeeComponent(Complex parent, String parentType, String name, Claim.PayeeComponent 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:"+parentType+'.'+name); 2727 } 2728 composeBackboneElement(t, "payee", name, element, index); 2729 if (element.hasType()) 2730 composeCodeableConcept(t, "Claim", "type", element.getType(), -1); 2731 if (element.hasResourceType()) 2732 composeCoding(t, "Claim", "resourceType", element.getResourceType(), -1); 2733 if (element.hasParty()) 2734 composeReference(t, "Claim", "party", element.getParty(), -1); 2735 } 2736 2737 protected void composeClaimCareTeamComponent(Complex parent, String parentType, String name, Claim.CareTeamComponent element, int index) { 2738 if (element == null) 2739 return; 2740 Complex t; 2741 if (Utilities.noString(parentType)) 2742 t = parent; 2743 else { 2744 t = parent.predicate("fhir:"+parentType+'.'+name); 2745 } 2746 composeBackboneElement(t, "careTeam", name, element, index); 2747 if (element.hasSequenceElement()) 2748 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2749 if (element.hasProvider()) 2750 composeReference(t, "Claim", "provider", element.getProvider(), -1); 2751 if (element.hasResponsibleElement()) 2752 composeBoolean(t, "Claim", "responsible", element.getResponsibleElement(), -1); 2753 if (element.hasRole()) 2754 composeCodeableConcept(t, "Claim", "role", element.getRole(), -1); 2755 if (element.hasQualification()) 2756 composeCodeableConcept(t, "Claim", "qualification", element.getQualification(), -1); 2757 } 2758 2759 protected void composeClaimSpecialConditionComponent(Complex parent, String parentType, String name, Claim.SpecialConditionComponent element, int index) { 2760 if (element == null) 2761 return; 2762 Complex t; 2763 if (Utilities.noString(parentType)) 2764 t = parent; 2765 else { 2766 t = parent.predicate("fhir:"+parentType+'.'+name); 2767 } 2768 composeBackboneElement(t, "information", name, element, index); 2769 if (element.hasSequenceElement()) 2770 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2771 if (element.hasCategory()) 2772 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 2773 if (element.hasCode()) 2774 composeCodeableConcept(t, "Claim", "code", element.getCode(), -1); 2775 if (element.hasTiming()) 2776 composeType(t, "Claim", "timing", element.getTiming(), -1); 2777 if (element.hasValue()) 2778 composeType(t, "Claim", "value", element.getValue(), -1); 2779 if (element.hasReason()) 2780 composeCodeableConcept(t, "Claim", "reason", element.getReason(), -1); 2781 } 2782 2783 protected void composeClaimDiagnosisComponent(Complex parent, String parentType, String name, Claim.DiagnosisComponent element, int index) { 2784 if (element == null) 2785 return; 2786 Complex t; 2787 if (Utilities.noString(parentType)) 2788 t = parent; 2789 else { 2790 t = parent.predicate("fhir:"+parentType+'.'+name); 2791 } 2792 composeBackboneElement(t, "diagnosis", name, element, index); 2793 if (element.hasSequenceElement()) 2794 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2795 if (element.hasDiagnosis()) 2796 composeType(t, "Claim", "diagnosis", element.getDiagnosis(), -1); 2797 for (int i = 0; i < element.getType().size(); i++) 2798 composeCodeableConcept(t, "Claim", "type", element.getType().get(i), i); 2799 if (element.hasPackageCode()) 2800 composeCodeableConcept(t, "Claim", "packageCode", element.getPackageCode(), -1); 2801 } 2802 2803 protected void composeClaimProcedureComponent(Complex parent, String parentType, String name, Claim.ProcedureComponent element, int index) { 2804 if (element == null) 2805 return; 2806 Complex t; 2807 if (Utilities.noString(parentType)) 2808 t = parent; 2809 else { 2810 t = parent.predicate("fhir:"+parentType+'.'+name); 2811 } 2812 composeBackboneElement(t, "procedure", name, element, index); 2813 if (element.hasSequenceElement()) 2814 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2815 if (element.hasDateElement()) 2816 composeDateTime(t, "Claim", "date", element.getDateElement(), -1); 2817 if (element.hasProcedure()) 2818 composeType(t, "Claim", "procedure", element.getProcedure(), -1); 2819 } 2820 2821 protected void composeClaimInsuranceComponent(Complex parent, String parentType, String name, Claim.InsuranceComponent element, int index) { 2822 if (element == null) 2823 return; 2824 Complex t; 2825 if (Utilities.noString(parentType)) 2826 t = parent; 2827 else { 2828 t = parent.predicate("fhir:"+parentType+'.'+name); 2829 } 2830 composeBackboneElement(t, "insurance", name, element, index); 2831 if (element.hasSequenceElement()) 2832 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2833 if (element.hasFocalElement()) 2834 composeBoolean(t, "Claim", "focal", element.getFocalElement(), -1); 2835 if (element.hasCoverage()) 2836 composeReference(t, "Claim", "coverage", element.getCoverage(), -1); 2837 if (element.hasBusinessArrangementElement()) 2838 composeString(t, "Claim", "businessArrangement", element.getBusinessArrangementElement(), -1); 2839 for (int i = 0; i < element.getPreAuthRef().size(); i++) 2840 composeString(t, "Claim", "preAuthRef", element.getPreAuthRef().get(i), i); 2841 if (element.hasClaimResponse()) 2842 composeReference(t, "Claim", "claimResponse", element.getClaimResponse(), -1); 2843 } 2844 2845 protected void composeClaimAccidentComponent(Complex parent, String parentType, String name, Claim.AccidentComponent element, int index) { 2846 if (element == null) 2847 return; 2848 Complex t; 2849 if (Utilities.noString(parentType)) 2850 t = parent; 2851 else { 2852 t = parent.predicate("fhir:"+parentType+'.'+name); 2853 } 2854 composeBackboneElement(t, "accident", name, element, index); 2855 if (element.hasDateElement()) 2856 composeDate(t, "Claim", "date", element.getDateElement(), -1); 2857 if (element.hasType()) 2858 composeCodeableConcept(t, "Claim", "type", element.getType(), -1); 2859 if (element.hasLocation()) 2860 composeType(t, "Claim", "location", element.getLocation(), -1); 2861 } 2862 2863 protected void composeClaimItemComponent(Complex parent, String parentType, String name, Claim.ItemComponent element, int index) { 2864 if (element == null) 2865 return; 2866 Complex t; 2867 if (Utilities.noString(parentType)) 2868 t = parent; 2869 else { 2870 t = parent.predicate("fhir:"+parentType+'.'+name); 2871 } 2872 composeBackboneElement(t, "item", name, element, index); 2873 if (element.hasSequenceElement()) 2874 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2875 for (int i = 0; i < element.getCareTeamLinkId().size(); i++) 2876 composePositiveInt(t, "Claim", "careTeamLinkId", element.getCareTeamLinkId().get(i), i); 2877 for (int i = 0; i < element.getDiagnosisLinkId().size(); i++) 2878 composePositiveInt(t, "Claim", "diagnosisLinkId", element.getDiagnosisLinkId().get(i), i); 2879 for (int i = 0; i < element.getProcedureLinkId().size(); i++) 2880 composePositiveInt(t, "Claim", "procedureLinkId", element.getProcedureLinkId().get(i), i); 2881 for (int i = 0; i < element.getInformationLinkId().size(); i++) 2882 composePositiveInt(t, "Claim", "informationLinkId", element.getInformationLinkId().get(i), i); 2883 if (element.hasRevenue()) 2884 composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1); 2885 if (element.hasCategory()) 2886 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 2887 if (element.hasService()) 2888 composeCodeableConcept(t, "Claim", "service", element.getService(), -1); 2889 for (int i = 0; i < element.getModifier().size(); i++) 2890 composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i); 2891 for (int i = 0; i < element.getProgramCode().size(); i++) 2892 composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i); 2893 if (element.hasServiced()) 2894 composeType(t, "Claim", "serviced", element.getServiced(), -1); 2895 if (element.hasLocation()) 2896 composeType(t, "Claim", "location", element.getLocation(), -1); 2897 if (element.hasQuantity()) 2898 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 2899 if (element.hasUnitPrice()) 2900 composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 2901 if (element.hasFactorElement()) 2902 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 2903 if (element.hasNet()) 2904 composeMoney(t, "Claim", "net", element.getNet(), -1); 2905 for (int i = 0; i < element.getUdi().size(); i++) 2906 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 2907 if (element.hasBodySite()) 2908 composeCodeableConcept(t, "Claim", "bodySite", element.getBodySite(), -1); 2909 for (int i = 0; i < element.getSubSite().size(); i++) 2910 composeCodeableConcept(t, "Claim", "subSite", element.getSubSite().get(i), i); 2911 for (int i = 0; i < element.getEncounter().size(); i++) 2912 composeReference(t, "Claim", "encounter", element.getEncounter().get(i), i); 2913 for (int i = 0; i < element.getDetail().size(); i++) 2914 composeClaimDetailComponent(t, "Claim", "detail", element.getDetail().get(i), i); 2915 } 2916 2917 protected void composeClaimDetailComponent(Complex parent, String parentType, String name, Claim.DetailComponent element, int index) { 2918 if (element == null) 2919 return; 2920 Complex t; 2921 if (Utilities.noString(parentType)) 2922 t = parent; 2923 else { 2924 t = parent.predicate("fhir:"+parentType+'.'+name); 2925 } 2926 composeBackboneElement(t, "detail", name, element, index); 2927 if (element.hasSequenceElement()) 2928 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2929 if (element.hasRevenue()) 2930 composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1); 2931 if (element.hasCategory()) 2932 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 2933 if (element.hasService()) 2934 composeCodeableConcept(t, "Claim", "service", element.getService(), -1); 2935 for (int i = 0; i < element.getModifier().size(); i++) 2936 composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i); 2937 for (int i = 0; i < element.getProgramCode().size(); i++) 2938 composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i); 2939 if (element.hasQuantity()) 2940 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 2941 if (element.hasUnitPrice()) 2942 composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 2943 if (element.hasFactorElement()) 2944 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 2945 if (element.hasNet()) 2946 composeMoney(t, "Claim", "net", element.getNet(), -1); 2947 for (int i = 0; i < element.getUdi().size(); i++) 2948 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 2949 for (int i = 0; i < element.getSubDetail().size(); i++) 2950 composeClaimSubDetailComponent(t, "Claim", "subDetail", element.getSubDetail().get(i), i); 2951 } 2952 2953 protected void composeClaimSubDetailComponent(Complex parent, String parentType, String name, Claim.SubDetailComponent element, int index) { 2954 if (element == null) 2955 return; 2956 Complex t; 2957 if (Utilities.noString(parentType)) 2958 t = parent; 2959 else { 2960 t = parent.predicate("fhir:"+parentType+'.'+name); 2961 } 2962 composeBackboneElement(t, "subDetail", name, element, index); 2963 if (element.hasSequenceElement()) 2964 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2965 if (element.hasRevenue()) 2966 composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1); 2967 if (element.hasCategory()) 2968 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 2969 if (element.hasService()) 2970 composeCodeableConcept(t, "Claim", "service", element.getService(), -1); 2971 for (int i = 0; i < element.getModifier().size(); i++) 2972 composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i); 2973 for (int i = 0; i < element.getProgramCode().size(); i++) 2974 composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i); 2975 if (element.hasQuantity()) 2976 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 2977 if (element.hasUnitPrice()) 2978 composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 2979 if (element.hasFactorElement()) 2980 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 2981 if (element.hasNet()) 2982 composeMoney(t, "Claim", "net", element.getNet(), -1); 2983 for (int i = 0; i < element.getUdi().size(); i++) 2984 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 2985 } 2986 2987 protected void composeClaimResponse(Complex parent, String parentType, String name, ClaimResponse element, int index) { 2988 if (element == null) 2989 return; 2990 Complex t; 2991 if (Utilities.noString(parentType)) 2992 t = parent; 2993 else { 2994 t = parent.predicate("fhir:"+parentType+'.'+name); 2995 } 2996 composeDomainResource(t, "ClaimResponse", name, element, index); 2997 for (int i = 0; i < element.getIdentifier().size(); i++) 2998 composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier().get(i), i); 2999 if (element.hasStatusElement()) 3000 composeEnum(t, "ClaimResponse", "status", element.getStatusElement(), -1); 3001 if (element.hasPatient()) 3002 composeReference(t, "ClaimResponse", "patient", element.getPatient(), -1); 3003 if (element.hasCreatedElement()) 3004 composeDateTime(t, "ClaimResponse", "created", element.getCreatedElement(), -1); 3005 if (element.hasInsurer()) 3006 composeReference(t, "ClaimResponse", "insurer", element.getInsurer(), -1); 3007 if (element.hasRequestProvider()) 3008 composeReference(t, "ClaimResponse", "requestProvider", element.getRequestProvider(), -1); 3009 if (element.hasRequestOrganization()) 3010 composeReference(t, "ClaimResponse", "requestOrganization", element.getRequestOrganization(), -1); 3011 if (element.hasRequest()) 3012 composeReference(t, "ClaimResponse", "request", element.getRequest(), -1); 3013 if (element.hasOutcome()) 3014 composeCodeableConcept(t, "ClaimResponse", "outcome", element.getOutcome(), -1); 3015 if (element.hasDispositionElement()) 3016 composeString(t, "ClaimResponse", "disposition", element.getDispositionElement(), -1); 3017 if (element.hasPayeeType()) 3018 composeCodeableConcept(t, "ClaimResponse", "payeeType", element.getPayeeType(), -1); 3019 for (int i = 0; i < element.getItem().size(); i++) 3020 composeClaimResponseItemComponent(t, "ClaimResponse", "item", element.getItem().get(i), i); 3021 for (int i = 0; i < element.getAddItem().size(); i++) 3022 composeClaimResponseAddedItemComponent(t, "ClaimResponse", "addItem", element.getAddItem().get(i), i); 3023 for (int i = 0; i < element.getError().size(); i++) 3024 composeClaimResponseErrorComponent(t, "ClaimResponse", "error", element.getError().get(i), i); 3025 if (element.hasTotalCost()) 3026 composeMoney(t, "ClaimResponse", "totalCost", element.getTotalCost(), -1); 3027 if (element.hasUnallocDeductable()) 3028 composeMoney(t, "ClaimResponse", "unallocDeductable", element.getUnallocDeductable(), -1); 3029 if (element.hasTotalBenefit()) 3030 composeMoney(t, "ClaimResponse", "totalBenefit", element.getTotalBenefit(), -1); 3031 if (element.hasPayment()) 3032 composeClaimResponsePaymentComponent(t, "ClaimResponse", "payment", element.getPayment(), -1); 3033 if (element.hasReserved()) 3034 composeCoding(t, "ClaimResponse", "reserved", element.getReserved(), -1); 3035 if (element.hasForm()) 3036 composeCodeableConcept(t, "ClaimResponse", "form", element.getForm(), -1); 3037 for (int i = 0; i < element.getProcessNote().size(); i++) 3038 composeClaimResponseNoteComponent(t, "ClaimResponse", "processNote", element.getProcessNote().get(i), i); 3039 for (int i = 0; i < element.getCommunicationRequest().size(); i++) 3040 composeReference(t, "ClaimResponse", "communicationRequest", element.getCommunicationRequest().get(i), i); 3041 for (int i = 0; i < element.getInsurance().size(); i++) 3042 composeClaimResponseInsuranceComponent(t, "ClaimResponse", "insurance", element.getInsurance().get(i), i); 3043 } 3044 3045 protected void composeClaimResponseItemComponent(Complex parent, String parentType, String name, ClaimResponse.ItemComponent element, int index) { 3046 if (element == null) 3047 return; 3048 Complex t; 3049 if (Utilities.noString(parentType)) 3050 t = parent; 3051 else { 3052 t = parent.predicate("fhir:"+parentType+'.'+name); 3053 } 3054 composeBackboneElement(t, "item", name, element, index); 3055 if (element.hasSequenceLinkIdElement()) 3056 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 3057 for (int i = 0; i < element.getNoteNumber().size(); i++) 3058 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3059 for (int i = 0; i < element.getAdjudication().size(); i++) 3060 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3061 for (int i = 0; i < element.getDetail().size(); i++) 3062 composeClaimResponseItemDetailComponent(t, "ClaimResponse", "detail", element.getDetail().get(i), i); 3063 } 3064 3065 protected void composeClaimResponseAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.AdjudicationComponent element, int index) { 3066 if (element == null) 3067 return; 3068 Complex t; 3069 if (Utilities.noString(parentType)) 3070 t = parent; 3071 else { 3072 t = parent.predicate("fhir:"+parentType+'.'+name); 3073 } 3074 composeBackboneElement(t, "adjudication", name, element, index); 3075 if (element.hasCategory()) 3076 composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1); 3077 if (element.hasReason()) 3078 composeCodeableConcept(t, "ClaimResponse", "reason", element.getReason(), -1); 3079 if (element.hasAmount()) 3080 composeMoney(t, "ClaimResponse", "amount", element.getAmount(), -1); 3081 if (element.hasValueElement()) 3082 composeDecimal(t, "ClaimResponse", "value", element.getValueElement(), -1); 3083 } 3084 3085 protected void composeClaimResponseItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.ItemDetailComponent 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:"+parentType+'.'+name); 3093 } 3094 composeBackboneElement(t, "detail", name, element, index); 3095 if (element.hasSequenceLinkIdElement()) 3096 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 3097 for (int i = 0; i < element.getNoteNumber().size(); i++) 3098 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3099 for (int i = 0; i < element.getAdjudication().size(); i++) 3100 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3101 for (int i = 0; i < element.getSubDetail().size(); i++) 3102 composeClaimResponseSubDetailComponent(t, "ClaimResponse", "subDetail", element.getSubDetail().get(i), i); 3103 } 3104 3105 protected void composeClaimResponseSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.SubDetailComponent element, int index) { 3106 if (element == null) 3107 return; 3108 Complex t; 3109 if (Utilities.noString(parentType)) 3110 t = parent; 3111 else { 3112 t = parent.predicate("fhir:"+parentType+'.'+name); 3113 } 3114 composeBackboneElement(t, "subDetail", name, element, index); 3115 if (element.hasSequenceLinkIdElement()) 3116 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 3117 for (int i = 0; i < element.getNoteNumber().size(); i++) 3118 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3119 for (int i = 0; i < element.getAdjudication().size(); i++) 3120 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3121 } 3122 3123 protected void composeClaimResponseAddedItemComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemComponent element, int index) { 3124 if (element == null) 3125 return; 3126 Complex t; 3127 if (Utilities.noString(parentType)) 3128 t = parent; 3129 else { 3130 t = parent.predicate("fhir:"+parentType+'.'+name); 3131 } 3132 composeBackboneElement(t, "addItem", name, element, index); 3133 for (int i = 0; i < element.getSequenceLinkId().size(); i++) 3134 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkId().get(i), i); 3135 if (element.hasRevenue()) 3136 composeCodeableConcept(t, "ClaimResponse", "revenue", element.getRevenue(), -1); 3137 if (element.hasCategory()) 3138 composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1); 3139 if (element.hasService()) 3140 composeCodeableConcept(t, "ClaimResponse", "service", element.getService(), -1); 3141 for (int i = 0; i < element.getModifier().size(); i++) 3142 composeCodeableConcept(t, "ClaimResponse", "modifier", element.getModifier().get(i), i); 3143 if (element.hasFee()) 3144 composeMoney(t, "ClaimResponse", "fee", element.getFee(), -1); 3145 for (int i = 0; i < element.getNoteNumber().size(); i++) 3146 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3147 for (int i = 0; i < element.getAdjudication().size(); i++) 3148 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3149 for (int i = 0; i < element.getDetail().size(); i++) 3150 composeClaimResponseAddedItemsDetailComponent(t, "ClaimResponse", "detail", element.getDetail().get(i), i); 3151 } 3152 3153 protected void composeClaimResponseAddedItemsDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemsDetailComponent element, int index) { 3154 if (element == null) 3155 return; 3156 Complex t; 3157 if (Utilities.noString(parentType)) 3158 t = parent; 3159 else { 3160 t = parent.predicate("fhir:"+parentType+'.'+name); 3161 } 3162 composeBackboneElement(t, "detail", name, element, index); 3163 if (element.hasRevenue()) 3164 composeCodeableConcept(t, "ClaimResponse", "revenue", element.getRevenue(), -1); 3165 if (element.hasCategory()) 3166 composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1); 3167 if (element.hasService()) 3168 composeCodeableConcept(t, "ClaimResponse", "service", element.getService(), -1); 3169 for (int i = 0; i < element.getModifier().size(); i++) 3170 composeCodeableConcept(t, "ClaimResponse", "modifier", element.getModifier().get(i), i); 3171 if (element.hasFee()) 3172 composeMoney(t, "ClaimResponse", "fee", element.getFee(), -1); 3173 for (int i = 0; i < element.getNoteNumber().size(); i++) 3174 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3175 for (int i = 0; i < element.getAdjudication().size(); i++) 3176 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3177 } 3178 3179 protected void composeClaimResponseErrorComponent(Complex parent, String parentType, String name, ClaimResponse.ErrorComponent element, int index) { 3180 if (element == null) 3181 return; 3182 Complex t; 3183 if (Utilities.noString(parentType)) 3184 t = parent; 3185 else { 3186 t = parent.predicate("fhir:"+parentType+'.'+name); 3187 } 3188 composeBackboneElement(t, "error", name, element, index); 3189 if (element.hasSequenceLinkIdElement()) 3190 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 3191 if (element.hasDetailSequenceLinkIdElement()) 3192 composePositiveInt(t, "ClaimResponse", "detailSequenceLinkId", element.getDetailSequenceLinkIdElement(), -1); 3193 if (element.hasSubdetailSequenceLinkIdElement()) 3194 composePositiveInt(t, "ClaimResponse", "subdetailSequenceLinkId", element.getSubdetailSequenceLinkIdElement(), -1); 3195 if (element.hasCode()) 3196 composeCodeableConcept(t, "ClaimResponse", "code", element.getCode(), -1); 3197 } 3198 3199 protected void composeClaimResponsePaymentComponent(Complex parent, String parentType, String name, ClaimResponse.PaymentComponent element, int index) { 3200 if (element == null) 3201 return; 3202 Complex t; 3203 if (Utilities.noString(parentType)) 3204 t = parent; 3205 else { 3206 t = parent.predicate("fhir:"+parentType+'.'+name); 3207 } 3208 composeBackboneElement(t, "payment", name, element, index); 3209 if (element.hasType()) 3210 composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1); 3211 if (element.hasAdjustment()) 3212 composeMoney(t, "ClaimResponse", "adjustment", element.getAdjustment(), -1); 3213 if (element.hasAdjustmentReason()) 3214 composeCodeableConcept(t, "ClaimResponse", "adjustmentReason", element.getAdjustmentReason(), -1); 3215 if (element.hasDateElement()) 3216 composeDate(t, "ClaimResponse", "date", element.getDateElement(), -1); 3217 if (element.hasAmount()) 3218 composeMoney(t, "ClaimResponse", "amount", element.getAmount(), -1); 3219 if (element.hasIdentifier()) 3220 composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier(), -1); 3221 } 3222 3223 protected void composeClaimResponseNoteComponent(Complex parent, String parentType, String name, ClaimResponse.NoteComponent element, int index) { 3224 if (element == null) 3225 return; 3226 Complex t; 3227 if (Utilities.noString(parentType)) 3228 t = parent; 3229 else { 3230 t = parent.predicate("fhir:"+parentType+'.'+name); 3231 } 3232 composeBackboneElement(t, "processNote", name, element, index); 3233 if (element.hasNumberElement()) 3234 composePositiveInt(t, "ClaimResponse", "number", element.getNumberElement(), -1); 3235 if (element.hasType()) 3236 composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1); 3237 if (element.hasTextElement()) 3238 composeString(t, "ClaimResponse", "text", element.getTextElement(), -1); 3239 if (element.hasLanguage()) 3240 composeCodeableConcept(t, "ClaimResponse", "language", element.getLanguage(), -1); 3241 } 3242 3243 protected void composeClaimResponseInsuranceComponent(Complex parent, String parentType, String name, ClaimResponse.InsuranceComponent element, int index) { 3244 if (element == null) 3245 return; 3246 Complex t; 3247 if (Utilities.noString(parentType)) 3248 t = parent; 3249 else { 3250 t = parent.predicate("fhir:"+parentType+'.'+name); 3251 } 3252 composeBackboneElement(t, "insurance", name, element, index); 3253 if (element.hasSequenceElement()) 3254 composePositiveInt(t, "ClaimResponse", "sequence", element.getSequenceElement(), -1); 3255 if (element.hasFocalElement()) 3256 composeBoolean(t, "ClaimResponse", "focal", element.getFocalElement(), -1); 3257 if (element.hasCoverage()) 3258 composeReference(t, "ClaimResponse", "coverage", element.getCoverage(), -1); 3259 if (element.hasBusinessArrangementElement()) 3260 composeString(t, "ClaimResponse", "businessArrangement", element.getBusinessArrangementElement(), -1); 3261 for (int i = 0; i < element.getPreAuthRef().size(); i++) 3262 composeString(t, "ClaimResponse", "preAuthRef", element.getPreAuthRef().get(i), i); 3263 if (element.hasClaimResponse()) 3264 composeReference(t, "ClaimResponse", "claimResponse", element.getClaimResponse(), -1); 3265 } 3266 3267 protected void composeClinicalImpression(Complex parent, String parentType, String name, ClinicalImpression element, int index) { 3268 if (element == null) 3269 return; 3270 Complex t; 3271 if (Utilities.noString(parentType)) 3272 t = parent; 3273 else { 3274 t = parent.predicate("fhir:"+parentType+'.'+name); 3275 } 3276 composeDomainResource(t, "ClinicalImpression", name, element, index); 3277 for (int i = 0; i < element.getIdentifier().size(); i++) 3278 composeIdentifier(t, "ClinicalImpression", "identifier", element.getIdentifier().get(i), i); 3279 if (element.hasStatusElement()) 3280 composeEnum(t, "ClinicalImpression", "status", element.getStatusElement(), -1); 3281 if (element.hasCode()) 3282 composeCodeableConcept(t, "ClinicalImpression", "code", element.getCode(), -1); 3283 if (element.hasDescriptionElement()) 3284 composeString(t, "ClinicalImpression", "description", element.getDescriptionElement(), -1); 3285 if (element.hasSubject()) 3286 composeReference(t, "ClinicalImpression", "subject", element.getSubject(), -1); 3287 if (element.hasContext()) 3288 composeReference(t, "ClinicalImpression", "context", element.getContext(), -1); 3289 if (element.hasEffective()) 3290 composeType(t, "ClinicalImpression", "effective", element.getEffective(), -1); 3291 if (element.hasDateElement()) 3292 composeDateTime(t, "ClinicalImpression", "date", element.getDateElement(), -1); 3293 if (element.hasAssessor()) 3294 composeReference(t, "ClinicalImpression", "assessor", element.getAssessor(), -1); 3295 if (element.hasPrevious()) 3296 composeReference(t, "ClinicalImpression", "previous", element.getPrevious(), -1); 3297 for (int i = 0; i < element.getProblem().size(); i++) 3298 composeReference(t, "ClinicalImpression", "problem", element.getProblem().get(i), i); 3299 for (int i = 0; i < element.getInvestigation().size(); i++) 3300 composeClinicalImpressionClinicalImpressionInvestigationComponent(t, "ClinicalImpression", "investigation", element.getInvestigation().get(i), i); 3301 for (int i = 0; i < element.getProtocol().size(); i++) 3302 composeUri(t, "ClinicalImpression", "protocol", element.getProtocol().get(i), i); 3303 if (element.hasSummaryElement()) 3304 composeString(t, "ClinicalImpression", "summary", element.getSummaryElement(), -1); 3305 for (int i = 0; i < element.getFinding().size(); i++) 3306 composeClinicalImpressionClinicalImpressionFindingComponent(t, "ClinicalImpression", "finding", element.getFinding().get(i), i); 3307 for (int i = 0; i < element.getPrognosisCodeableConcept().size(); i++) 3308 composeCodeableConcept(t, "ClinicalImpression", "prognosisCodeableConcept", element.getPrognosisCodeableConcept().get(i), i); 3309 for (int i = 0; i < element.getPrognosisReference().size(); i++) 3310 composeReference(t, "ClinicalImpression", "prognosisReference", element.getPrognosisReference().get(i), i); 3311 for (int i = 0; i < element.getAction().size(); i++) 3312 composeReference(t, "ClinicalImpression", "action", element.getAction().get(i), i); 3313 for (int i = 0; i < element.getNote().size(); i++) 3314 composeAnnotation(t, "ClinicalImpression", "note", element.getNote().get(i), i); 3315 } 3316 3317 protected void composeClinicalImpressionClinicalImpressionInvestigationComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionInvestigationComponent element, int index) { 3318 if (element == null) 3319 return; 3320 Complex t; 3321 if (Utilities.noString(parentType)) 3322 t = parent; 3323 else { 3324 t = parent.predicate("fhir:"+parentType+'.'+name); 3325 } 3326 composeBackboneElement(t, "investigation", name, element, index); 3327 if (element.hasCode()) 3328 composeCodeableConcept(t, "ClinicalImpression", "code", element.getCode(), -1); 3329 for (int i = 0; i < element.getItem().size(); i++) 3330 composeReference(t, "ClinicalImpression", "item", element.getItem().get(i), i); 3331 } 3332 3333 protected void composeClinicalImpressionClinicalImpressionFindingComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionFindingComponent element, int index) { 3334 if (element == null) 3335 return; 3336 Complex t; 3337 if (Utilities.noString(parentType)) 3338 t = parent; 3339 else { 3340 t = parent.predicate("fhir:"+parentType+'.'+name); 3341 } 3342 composeBackboneElement(t, "finding", name, element, index); 3343 if (element.hasItem()) 3344 composeType(t, "ClinicalImpression", "item", element.getItem(), -1); 3345 if (element.hasBasisElement()) 3346 composeString(t, "ClinicalImpression", "basis", element.getBasisElement(), -1); 3347 } 3348 3349 protected void composeCodeSystem(Complex parent, String parentType, String name, CodeSystem element, int index) { 3350 if (element == null) 3351 return; 3352 Complex t; 3353 if (Utilities.noString(parentType)) 3354 t = parent; 3355 else { 3356 t = parent.predicate("fhir:"+parentType+'.'+name); 3357 } 3358 composeDomainResource(t, "CodeSystem", name, element, index); 3359 if (element.hasUrlElement()) 3360 composeUri(t, "CodeSystem", "url", element.getUrlElement(), -1); 3361 if (element.hasIdentifier()) 3362 composeIdentifier(t, "CodeSystem", "identifier", element.getIdentifier(), -1); 3363 if (element.hasVersionElement()) 3364 composeString(t, "CodeSystem", "version", element.getVersionElement(), -1); 3365 if (element.hasNameElement()) 3366 composeString(t, "CodeSystem", "name", element.getNameElement(), -1); 3367 if (element.hasTitleElement()) 3368 composeString(t, "CodeSystem", "title", element.getTitleElement(), -1); 3369 if (element.hasStatusElement()) 3370 composeEnum(t, "CodeSystem", "status", element.getStatusElement(), -1); 3371 if (element.hasExperimentalElement()) 3372 composeBoolean(t, "CodeSystem", "experimental", element.getExperimentalElement(), -1); 3373 if (element.hasDateElement()) 3374 composeDateTime(t, "CodeSystem", "date", element.getDateElement(), -1); 3375 if (element.hasPublisherElement()) 3376 composeString(t, "CodeSystem", "publisher", element.getPublisherElement(), -1); 3377 for (int i = 0; i < element.getContact().size(); i++) 3378 composeContactDetail(t, "CodeSystem", "contact", element.getContact().get(i), i); 3379 if (element.hasDescriptionElement()) 3380 composeMarkdown(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 3381 for (int i = 0; i < element.getUseContext().size(); i++) 3382 composeUsageContext(t, "CodeSystem", "useContext", element.getUseContext().get(i), i); 3383 for (int i = 0; i < element.getJurisdiction().size(); i++) 3384 composeCodeableConcept(t, "CodeSystem", "jurisdiction", element.getJurisdiction().get(i), i); 3385 if (element.hasPurposeElement()) 3386 composeMarkdown(t, "CodeSystem", "purpose", element.getPurposeElement(), -1); 3387 if (element.hasCopyrightElement()) 3388 composeMarkdown(t, "CodeSystem", "copyright", element.getCopyrightElement(), -1); 3389 if (element.hasCaseSensitiveElement()) 3390 composeBoolean(t, "CodeSystem", "caseSensitive", element.getCaseSensitiveElement(), -1); 3391 if (element.hasValueSetElement()) 3392 composeUri(t, "CodeSystem", "valueSet", element.getValueSetElement(), -1); 3393 if (element.hasHierarchyMeaningElement()) 3394 composeEnum(t, "CodeSystem", "hierarchyMeaning", element.getHierarchyMeaningElement(), -1); 3395 if (element.hasCompositionalElement()) 3396 composeBoolean(t, "CodeSystem", "compositional", element.getCompositionalElement(), -1); 3397 if (element.hasVersionNeededElement()) 3398 composeBoolean(t, "CodeSystem", "versionNeeded", element.getVersionNeededElement(), -1); 3399 if (element.hasContentElement()) 3400 composeEnum(t, "CodeSystem", "content", element.getContentElement(), -1); 3401 if (element.hasCountElement()) 3402 composeUnsignedInt(t, "CodeSystem", "count", element.getCountElement(), -1); 3403 for (int i = 0; i < element.getFilter().size(); i++) 3404 composeCodeSystemCodeSystemFilterComponent(t, "CodeSystem", "filter", element.getFilter().get(i), i); 3405 for (int i = 0; i < element.getProperty().size(); i++) 3406 composeCodeSystemPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i); 3407 for (int i = 0; i < element.getConcept().size(); i++) 3408 composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i); 3409 } 3410 3411 protected void composeCodeSystemCodeSystemFilterComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemFilterComponent element, int index) { 3412 if (element == null) 3413 return; 3414 Complex t; 3415 if (Utilities.noString(parentType)) 3416 t = parent; 3417 else { 3418 t = parent.predicate("fhir:"+parentType+'.'+name); 3419 } 3420 composeBackboneElement(t, "filter", name, element, index); 3421 if (element.hasCodeElement()) 3422 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 3423 if (element.hasDescriptionElement()) 3424 composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 3425 for (int i = 0; i < element.getOperator().size(); i++) 3426 composeEnum(t, "CodeSystem", "operator", element.getOperator().get(i), i); 3427 if (element.hasValueElement()) 3428 composeString(t, "CodeSystem", "value", element.getValueElement(), -1); 3429 } 3430 3431 protected void composeCodeSystemPropertyComponent(Complex parent, String parentType, String name, CodeSystem.PropertyComponent element, int index) { 3432 if (element == null) 3433 return; 3434 Complex t; 3435 if (Utilities.noString(parentType)) 3436 t = parent; 3437 else { 3438 t = parent.predicate("fhir:"+parentType+'.'+name); 3439 } 3440 composeBackboneElement(t, "property", name, element, index); 3441 if (element.hasCodeElement()) 3442 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 3443 if (element.hasUriElement()) 3444 composeUri(t, "CodeSystem", "uri", element.getUriElement(), -1); 3445 if (element.hasDescriptionElement()) 3446 composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 3447 if (element.hasTypeElement()) 3448 composeEnum(t, "CodeSystem", "type", element.getTypeElement(), -1); 3449 } 3450 3451 protected void composeCodeSystemConceptDefinitionComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionComponent element, int index) { 3452 if (element == null) 3453 return; 3454 Complex t; 3455 if (Utilities.noString(parentType)) 3456 t = parent; 3457 else { 3458 t = parent.predicate("fhir:"+parentType+'.'+name); 3459 } 3460 composeBackboneElement(t, "concept", name, element, index); 3461 if (element.hasCodeElement()) 3462 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 3463 if (element.hasDisplayElement()) 3464 composeString(t, "CodeSystem", "display", element.getDisplayElement(), -1); 3465 if (element.hasDefinitionElement()) 3466 composeString(t, "CodeSystem", "definition", element.getDefinitionElement(), -1); 3467 for (int i = 0; i < element.getDesignation().size(); i++) 3468 composeCodeSystemConceptDefinitionDesignationComponent(t, "CodeSystem", "designation", element.getDesignation().get(i), i); 3469 for (int i = 0; i < element.getProperty().size(); i++) 3470 composeCodeSystemConceptPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i); 3471 for (int i = 0; i < element.getConcept().size(); i++) 3472 composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i); 3473 } 3474 3475 protected void composeCodeSystemConceptDefinitionDesignationComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionDesignationComponent element, int index) { 3476 if (element == null) 3477 return; 3478 Complex t; 3479 if (Utilities.noString(parentType)) 3480 t = parent; 3481 else { 3482 t = parent.predicate("fhir:"+parentType+'.'+name); 3483 } 3484 composeBackboneElement(t, "designation", name, element, index); 3485 if (element.hasLanguageElement()) 3486 composeCode(t, "CodeSystem", "language", element.getLanguageElement(), -1); 3487 if (element.hasUse()) 3488 composeCoding(t, "CodeSystem", "use", element.getUse(), -1); 3489 if (element.hasValueElement()) 3490 composeString(t, "CodeSystem", "value", element.getValueElement(), -1); 3491 } 3492 3493 protected void composeCodeSystemConceptPropertyComponent(Complex parent, String parentType, String name, CodeSystem.ConceptPropertyComponent element, int index) { 3494 if (element == null) 3495 return; 3496 Complex t; 3497 if (Utilities.noString(parentType)) 3498 t = parent; 3499 else { 3500 t = parent.predicate("fhir:"+parentType+'.'+name); 3501 } 3502 composeBackboneElement(t, "property", name, element, index); 3503 if (element.hasCodeElement()) 3504 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 3505 if (element.hasValue()) 3506 composeType(t, "CodeSystem", "value", element.getValue(), -1); 3507 } 3508 3509 protected void composeCommunication(Complex parent, String parentType, String name, Communication element, int index) { 3510 if (element == null) 3511 return; 3512 Complex t; 3513 if (Utilities.noString(parentType)) 3514 t = parent; 3515 else { 3516 t = parent.predicate("fhir:"+parentType+'.'+name); 3517 } 3518 composeDomainResource(t, "Communication", name, element, index); 3519 for (int i = 0; i < element.getIdentifier().size(); i++) 3520 composeIdentifier(t, "Communication", "identifier", element.getIdentifier().get(i), i); 3521 for (int i = 0; i < element.getDefinition().size(); i++) 3522 composeReference(t, "Communication", "definition", element.getDefinition().get(i), i); 3523 for (int i = 0; i < element.getBasedOn().size(); i++) 3524 composeReference(t, "Communication", "basedOn", element.getBasedOn().get(i), i); 3525 for (int i = 0; i < element.getPartOf().size(); i++) 3526 composeReference(t, "Communication", "partOf", element.getPartOf().get(i), i); 3527 if (element.hasStatusElement()) 3528 composeEnum(t, "Communication", "status", element.getStatusElement(), -1); 3529 if (element.hasNotDoneElement()) 3530 composeBoolean(t, "Communication", "notDone", element.getNotDoneElement(), -1); 3531 if (element.hasNotDoneReason()) 3532 composeCodeableConcept(t, "Communication", "notDoneReason", element.getNotDoneReason(), -1); 3533 for (int i = 0; i < element.getCategory().size(); i++) 3534 composeCodeableConcept(t, "Communication", "category", element.getCategory().get(i), i); 3535 for (int i = 0; i < element.getMedium().size(); i++) 3536 composeCodeableConcept(t, "Communication", "medium", element.getMedium().get(i), i); 3537 if (element.hasSubject()) 3538 composeReference(t, "Communication", "subject", element.getSubject(), -1); 3539 for (int i = 0; i < element.getRecipient().size(); i++) 3540 composeReference(t, "Communication", "recipient", element.getRecipient().get(i), i); 3541 for (int i = 0; i < element.getTopic().size(); i++) 3542 composeReference(t, "Communication", "topic", element.getTopic().get(i), i); 3543 if (element.hasContext()) 3544 composeReference(t, "Communication", "context", element.getContext(), -1); 3545 if (element.hasSentElement()) 3546 composeDateTime(t, "Communication", "sent", element.getSentElement(), -1); 3547 if (element.hasReceivedElement()) 3548 composeDateTime(t, "Communication", "received", element.getReceivedElement(), -1); 3549 if (element.hasSender()) 3550 composeReference(t, "Communication", "sender", element.getSender(), -1); 3551 for (int i = 0; i < element.getReasonCode().size(); i++) 3552 composeCodeableConcept(t, "Communication", "reasonCode", element.getReasonCode().get(i), i); 3553 for (int i = 0; i < element.getReasonReference().size(); i++) 3554 composeReference(t, "Communication", "reasonReference", element.getReasonReference().get(i), i); 3555 for (int i = 0; i < element.getPayload().size(); i++) 3556 composeCommunicationCommunicationPayloadComponent(t, "Communication", "payload", element.getPayload().get(i), i); 3557 for (int i = 0; i < element.getNote().size(); i++) 3558 composeAnnotation(t, "Communication", "note", element.getNote().get(i), i); 3559 } 3560 3561 protected void composeCommunicationCommunicationPayloadComponent(Complex parent, String parentType, String name, Communication.CommunicationPayloadComponent element, int index) { 3562 if (element == null) 3563 return; 3564 Complex t; 3565 if (Utilities.noString(parentType)) 3566 t = parent; 3567 else { 3568 t = parent.predicate("fhir:"+parentType+'.'+name); 3569 } 3570 composeBackboneElement(t, "payload", name, element, index); 3571 if (element.hasContent()) 3572 composeType(t, "Communication", "content", element.getContent(), -1); 3573 } 3574 3575 protected void composeCommunicationRequest(Complex parent, String parentType, String name, CommunicationRequest element, int index) { 3576 if (element == null) 3577 return; 3578 Complex t; 3579 if (Utilities.noString(parentType)) 3580 t = parent; 3581 else { 3582 t = parent.predicate("fhir:"+parentType+'.'+name); 3583 } 3584 composeDomainResource(t, "CommunicationRequest", name, element, index); 3585 for (int i = 0; i < element.getIdentifier().size(); i++) 3586 composeIdentifier(t, "CommunicationRequest", "identifier", element.getIdentifier().get(i), i); 3587 for (int i = 0; i < element.getBasedOn().size(); i++) 3588 composeReference(t, "CommunicationRequest", "basedOn", element.getBasedOn().get(i), i); 3589 for (int i = 0; i < element.getReplaces().size(); i++) 3590 composeReference(t, "CommunicationRequest", "replaces", element.getReplaces().get(i), i); 3591 if (element.hasGroupIdentifier()) 3592 composeIdentifier(t, "CommunicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 3593 if (element.hasStatusElement()) 3594 composeEnum(t, "CommunicationRequest", "status", element.getStatusElement(), -1); 3595 for (int i = 0; i < element.getCategory().size(); i++) 3596 composeCodeableConcept(t, "CommunicationRequest", "category", element.getCategory().get(i), i); 3597 if (element.hasPriorityElement()) 3598 composeEnum(t, "CommunicationRequest", "priority", element.getPriorityElement(), -1); 3599 for (int i = 0; i < element.getMedium().size(); i++) 3600 composeCodeableConcept(t, "CommunicationRequest", "medium", element.getMedium().get(i), i); 3601 if (element.hasSubject()) 3602 composeReference(t, "CommunicationRequest", "subject", element.getSubject(), -1); 3603 for (int i = 0; i < element.getRecipient().size(); i++) 3604 composeReference(t, "CommunicationRequest", "recipient", element.getRecipient().get(i), i); 3605 for (int i = 0; i < element.getTopic().size(); i++) 3606 composeReference(t, "CommunicationRequest", "topic", element.getTopic().get(i), i); 3607 if (element.hasContext()) 3608 composeReference(t, "CommunicationRequest", "context", element.getContext(), -1); 3609 for (int i = 0; i < element.getPayload().size(); i++) 3610 composeCommunicationRequestCommunicationRequestPayloadComponent(t, "CommunicationRequest", "payload", element.getPayload().get(i), i); 3611 if (element.hasOccurrence()) 3612 composeType(t, "CommunicationRequest", "occurrence", element.getOccurrence(), -1); 3613 if (element.hasAuthoredOnElement()) 3614 composeDateTime(t, "CommunicationRequest", "authoredOn", element.getAuthoredOnElement(), -1); 3615 if (element.hasSender()) 3616 composeReference(t, "CommunicationRequest", "sender", element.getSender(), -1); 3617 if (element.hasRequester()) 3618 composeCommunicationRequestCommunicationRequestRequesterComponent(t, "CommunicationRequest", "requester", element.getRequester(), -1); 3619 for (int i = 0; i < element.getReasonCode().size(); i++) 3620 composeCodeableConcept(t, "CommunicationRequest", "reasonCode", element.getReasonCode().get(i), i); 3621 for (int i = 0; i < element.getReasonReference().size(); i++) 3622 composeReference(t, "CommunicationRequest", "reasonReference", element.getReasonReference().get(i), i); 3623 for (int i = 0; i < element.getNote().size(); i++) 3624 composeAnnotation(t, "CommunicationRequest", "note", element.getNote().get(i), i); 3625 } 3626 3627 protected void composeCommunicationRequestCommunicationRequestPayloadComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestPayloadComponent element, int index) { 3628 if (element == null) 3629 return; 3630 Complex t; 3631 if (Utilities.noString(parentType)) 3632 t = parent; 3633 else { 3634 t = parent.predicate("fhir:"+parentType+'.'+name); 3635 } 3636 composeBackboneElement(t, "payload", name, element, index); 3637 if (element.hasContent()) 3638 composeType(t, "CommunicationRequest", "content", element.getContent(), -1); 3639 } 3640 3641 protected void composeCommunicationRequestCommunicationRequestRequesterComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestRequesterComponent element, int index) { 3642 if (element == null) 3643 return; 3644 Complex t; 3645 if (Utilities.noString(parentType)) 3646 t = parent; 3647 else { 3648 t = parent.predicate("fhir:"+parentType+'.'+name); 3649 } 3650 composeBackboneElement(t, "requester", name, element, index); 3651 if (element.hasAgent()) 3652 composeReference(t, "CommunicationRequest", "agent", element.getAgent(), -1); 3653 if (element.hasOnBehalfOf()) 3654 composeReference(t, "CommunicationRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 3655 } 3656 3657 protected void composeCompartmentDefinition(Complex parent, String parentType, String name, CompartmentDefinition element, int index) { 3658 if (element == null) 3659 return; 3660 Complex t; 3661 if (Utilities.noString(parentType)) 3662 t = parent; 3663 else { 3664 t = parent.predicate("fhir:"+parentType+'.'+name); 3665 } 3666 composeDomainResource(t, "CompartmentDefinition", name, element, index); 3667 if (element.hasUrlElement()) 3668 composeUri(t, "CompartmentDefinition", "url", element.getUrlElement(), -1); 3669 if (element.hasNameElement()) 3670 composeString(t, "CompartmentDefinition", "name", element.getNameElement(), -1); 3671 if (element.hasTitleElement()) 3672 composeString(t, "CompartmentDefinition", "title", element.getTitleElement(), -1); 3673 if (element.hasStatusElement()) 3674 composeEnum(t, "CompartmentDefinition", "status", element.getStatusElement(), -1); 3675 if (element.hasExperimentalElement()) 3676 composeBoolean(t, "CompartmentDefinition", "experimental", element.getExperimentalElement(), -1); 3677 if (element.hasDateElement()) 3678 composeDateTime(t, "CompartmentDefinition", "date", element.getDateElement(), -1); 3679 if (element.hasPublisherElement()) 3680 composeString(t, "CompartmentDefinition", "publisher", element.getPublisherElement(), -1); 3681 for (int i = 0; i < element.getContact().size(); i++) 3682 composeContactDetail(t, "CompartmentDefinition", "contact", element.getContact().get(i), i); 3683 if (element.hasDescriptionElement()) 3684 composeMarkdown(t, "CompartmentDefinition", "description", element.getDescriptionElement(), -1); 3685 if (element.hasPurposeElement()) 3686 composeMarkdown(t, "CompartmentDefinition", "purpose", element.getPurposeElement(), -1); 3687 for (int i = 0; i < element.getUseContext().size(); i++) 3688 composeUsageContext(t, "CompartmentDefinition", "useContext", element.getUseContext().get(i), i); 3689 for (int i = 0; i < element.getJurisdiction().size(); i++) 3690 composeCodeableConcept(t, "CompartmentDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 3691 if (element.hasCodeElement()) 3692 composeEnum(t, "CompartmentDefinition", "code", element.getCodeElement(), -1); 3693 if (element.hasSearchElement()) 3694 composeBoolean(t, "CompartmentDefinition", "search", element.getSearchElement(), -1); 3695 for (int i = 0; i < element.getResource().size(); i++) 3696 composeCompartmentDefinitionCompartmentDefinitionResourceComponent(t, "CompartmentDefinition", "resource", element.getResource().get(i), i); 3697 } 3698 3699 protected void composeCompartmentDefinitionCompartmentDefinitionResourceComponent(Complex parent, String parentType, String name, CompartmentDefinition.CompartmentDefinitionResourceComponent element, int index) { 3700 if (element == null) 3701 return; 3702 Complex t; 3703 if (Utilities.noString(parentType)) 3704 t = parent; 3705 else { 3706 t = parent.predicate("fhir:"+parentType+'.'+name); 3707 } 3708 composeBackboneElement(t, "resource", name, element, index); 3709 if (element.hasCodeElement()) 3710 composeCode(t, "CompartmentDefinition", "code", element.getCodeElement(), -1); 3711 for (int i = 0; i < element.getParam().size(); i++) 3712 composeString(t, "CompartmentDefinition", "param", element.getParam().get(i), i); 3713 if (element.hasDocumentationElement()) 3714 composeString(t, "CompartmentDefinition", "documentation", element.getDocumentationElement(), -1); 3715 } 3716 3717 protected void composeComposition(Complex parent, String parentType, String name, Composition element, int index) { 3718 if (element == null) 3719 return; 3720 Complex t; 3721 if (Utilities.noString(parentType)) 3722 t = parent; 3723 else { 3724 t = parent.predicate("fhir:"+parentType+'.'+name); 3725 } 3726 composeDomainResource(t, "Composition", name, element, index); 3727 if (element.hasIdentifier()) 3728 composeIdentifier(t, "Composition", "identifier", element.getIdentifier(), -1); 3729 if (element.hasStatusElement()) 3730 composeEnum(t, "Composition", "status", element.getStatusElement(), -1); 3731 if (element.hasType()) 3732 composeCodeableConcept(t, "Composition", "type", element.getType(), -1); 3733 if (element.hasClass_()) 3734 composeCodeableConcept(t, "Composition", "class", element.getClass_(), -1); 3735 if (element.hasSubject()) 3736 composeReference(t, "Composition", "subject", element.getSubject(), -1); 3737 if (element.hasEncounter()) 3738 composeReference(t, "Composition", "encounter", element.getEncounter(), -1); 3739 if (element.hasDateElement()) 3740 composeDateTime(t, "Composition", "date", element.getDateElement(), -1); 3741 for (int i = 0; i < element.getAuthor().size(); i++) 3742 composeReference(t, "Composition", "author", element.getAuthor().get(i), i); 3743 if (element.hasTitleElement()) 3744 composeString(t, "Composition", "title", element.getTitleElement(), -1); 3745 if (element.hasConfidentialityElement()) 3746 composeEnum(t, "Composition", "confidentiality", element.getConfidentialityElement(), -1); 3747 for (int i = 0; i < element.getAttester().size(); i++) 3748 composeCompositionCompositionAttesterComponent(t, "Composition", "attester", element.getAttester().get(i), i); 3749 if (element.hasCustodian()) 3750 composeReference(t, "Composition", "custodian", element.getCustodian(), -1); 3751 for (int i = 0; i < element.getRelatesTo().size(); i++) 3752 composeCompositionCompositionRelatesToComponent(t, "Composition", "relatesTo", element.getRelatesTo().get(i), i); 3753 for (int i = 0; i < element.getEvent().size(); i++) 3754 composeCompositionCompositionEventComponent(t, "Composition", "event", element.getEvent().get(i), i); 3755 for (int i = 0; i < element.getSection().size(); i++) 3756 composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i); 3757 } 3758 3759 protected void composeCompositionCompositionAttesterComponent(Complex parent, String parentType, String name, Composition.CompositionAttesterComponent element, int index) { 3760 if (element == null) 3761 return; 3762 Complex t; 3763 if (Utilities.noString(parentType)) 3764 t = parent; 3765 else { 3766 t = parent.predicate("fhir:"+parentType+'.'+name); 3767 } 3768 composeBackboneElement(t, "attester", name, element, index); 3769 for (int i = 0; i < element.getMode().size(); i++) 3770 composeEnum(t, "Composition", "mode", element.getMode().get(i), i); 3771 if (element.hasTimeElement()) 3772 composeDateTime(t, "Composition", "time", element.getTimeElement(), -1); 3773 if (element.hasParty()) 3774 composeReference(t, "Composition", "party", element.getParty(), -1); 3775 } 3776 3777 protected void composeCompositionCompositionRelatesToComponent(Complex parent, String parentType, String name, Composition.CompositionRelatesToComponent element, int index) { 3778 if (element == null) 3779 return; 3780 Complex t; 3781 if (Utilities.noString(parentType)) 3782 t = parent; 3783 else { 3784 t = parent.predicate("fhir:"+parentType+'.'+name); 3785 } 3786 composeBackboneElement(t, "relatesTo", name, element, index); 3787 if (element.hasCodeElement()) 3788 composeEnum(t, "Composition", "code", element.getCodeElement(), -1); 3789 if (element.hasTarget()) 3790 composeType(t, "Composition", "target", element.getTarget(), -1); 3791 } 3792 3793 protected void composeCompositionCompositionEventComponent(Complex parent, String parentType, String name, Composition.CompositionEventComponent 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:"+parentType+'.'+name); 3801 } 3802 composeBackboneElement(t, "event", name, element, index); 3803 for (int i = 0; i < element.getCode().size(); i++) 3804 composeCodeableConcept(t, "Composition", "code", element.getCode().get(i), i); 3805 if (element.hasPeriod()) 3806 composePeriod(t, "Composition", "period", element.getPeriod(), -1); 3807 for (int i = 0; i < element.getDetail().size(); i++) 3808 composeReference(t, "Composition", "detail", element.getDetail().get(i), i); 3809 } 3810 3811 protected void composeCompositionSectionComponent(Complex parent, String parentType, String name, Composition.SectionComponent element, int index) { 3812 if (element == null) 3813 return; 3814 Complex t; 3815 if (Utilities.noString(parentType)) 3816 t = parent; 3817 else { 3818 t = parent.predicate("fhir:"+parentType+'.'+name); 3819 } 3820 composeBackboneElement(t, "section", name, element, index); 3821 if (element.hasTitleElement()) 3822 composeString(t, "Composition", "title", element.getTitleElement(), -1); 3823 if (element.hasCode()) 3824 composeCodeableConcept(t, "Composition", "code", element.getCode(), -1); 3825 if (element.hasText()) 3826 composeNarrative(t, "Composition", "text", element.getText(), -1); 3827 if (element.hasModeElement()) 3828 composeEnum(t, "Composition", "mode", element.getModeElement(), -1); 3829 if (element.hasOrderedBy()) 3830 composeCodeableConcept(t, "Composition", "orderedBy", element.getOrderedBy(), -1); 3831 for (int i = 0; i < element.getEntry().size(); i++) 3832 composeReference(t, "Composition", "entry", element.getEntry().get(i), i); 3833 if (element.hasEmptyReason()) 3834 composeCodeableConcept(t, "Composition", "emptyReason", element.getEmptyReason(), -1); 3835 for (int i = 0; i < element.getSection().size(); i++) 3836 composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i); 3837 } 3838 3839 protected void composeConceptMap(Complex parent, String parentType, String name, ConceptMap element, int index) { 3840 if (element == null) 3841 return; 3842 Complex t; 3843 if (Utilities.noString(parentType)) 3844 t = parent; 3845 else { 3846 t = parent.predicate("fhir:"+parentType+'.'+name); 3847 } 3848 composeDomainResource(t, "ConceptMap", name, element, index); 3849 if (element.hasUrlElement()) 3850 composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1); 3851 if (element.hasIdentifier()) 3852 composeIdentifier(t, "ConceptMap", "identifier", element.getIdentifier(), -1); 3853 if (element.hasVersionElement()) 3854 composeString(t, "ConceptMap", "version", element.getVersionElement(), -1); 3855 if (element.hasNameElement()) 3856 composeString(t, "ConceptMap", "name", element.getNameElement(), -1); 3857 if (element.hasTitleElement()) 3858 composeString(t, "ConceptMap", "title", element.getTitleElement(), -1); 3859 if (element.hasStatusElement()) 3860 composeEnum(t, "ConceptMap", "status", element.getStatusElement(), -1); 3861 if (element.hasExperimentalElement()) 3862 composeBoolean(t, "ConceptMap", "experimental", element.getExperimentalElement(), -1); 3863 if (element.hasDateElement()) 3864 composeDateTime(t, "ConceptMap", "date", element.getDateElement(), -1); 3865 if (element.hasPublisherElement()) 3866 composeString(t, "ConceptMap", "publisher", element.getPublisherElement(), -1); 3867 for (int i = 0; i < element.getContact().size(); i++) 3868 composeContactDetail(t, "ConceptMap", "contact", element.getContact().get(i), i); 3869 if (element.hasDescriptionElement()) 3870 composeMarkdown(t, "ConceptMap", "description", element.getDescriptionElement(), -1); 3871 for (int i = 0; i < element.getUseContext().size(); i++) 3872 composeUsageContext(t, "ConceptMap", "useContext", element.getUseContext().get(i), i); 3873 for (int i = 0; i < element.getJurisdiction().size(); i++) 3874 composeCodeableConcept(t, "ConceptMap", "jurisdiction", element.getJurisdiction().get(i), i); 3875 if (element.hasPurposeElement()) 3876 composeMarkdown(t, "ConceptMap", "purpose", element.getPurposeElement(), -1); 3877 if (element.hasCopyrightElement()) 3878 composeMarkdown(t, "ConceptMap", "copyright", element.getCopyrightElement(), -1); 3879 if (element.hasSource()) 3880 composeType(t, "ConceptMap", "source", element.getSource(), -1); 3881 if (element.hasTarget()) 3882 composeType(t, "ConceptMap", "target", element.getTarget(), -1); 3883 for (int i = 0; i < element.getGroup().size(); i++) 3884 composeConceptMapConceptMapGroupComponent(t, "ConceptMap", "group", element.getGroup().get(i), i); 3885 } 3886 3887 protected void composeConceptMapConceptMapGroupComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupComponent element, int index) { 3888 if (element == null) 3889 return; 3890 Complex t; 3891 if (Utilities.noString(parentType)) 3892 t = parent; 3893 else { 3894 t = parent.predicate("fhir:"+parentType+'.'+name); 3895 } 3896 composeBackboneElement(t, "group", name, element, index); 3897 if (element.hasSourceElement()) 3898 composeUri(t, "ConceptMap", "source", element.getSourceElement(), -1); 3899 if (element.hasSourceVersionElement()) 3900 composeString(t, "ConceptMap", "sourceVersion", element.getSourceVersionElement(), -1); 3901 if (element.hasTargetElement()) 3902 composeUri(t, "ConceptMap", "target", element.getTargetElement(), -1); 3903 if (element.hasTargetVersionElement()) 3904 composeString(t, "ConceptMap", "targetVersion", element.getTargetVersionElement(), -1); 3905 for (int i = 0; i < element.getElement().size(); i++) 3906 composeConceptMapSourceElementComponent(t, "ConceptMap", "element", element.getElement().get(i), i); 3907 if (element.hasUnmapped()) 3908 composeConceptMapConceptMapGroupUnmappedComponent(t, "ConceptMap", "unmapped", element.getUnmapped(), -1); 3909 } 3910 3911 protected void composeConceptMapSourceElementComponent(Complex parent, String parentType, String name, ConceptMap.SourceElementComponent element, int index) { 3912 if (element == null) 3913 return; 3914 Complex t; 3915 if (Utilities.noString(parentType)) 3916 t = parent; 3917 else { 3918 t = parent.predicate("fhir:"+parentType+'.'+name); 3919 } 3920 composeBackboneElement(t, "element", name, element, index); 3921 if (element.hasCodeElement()) 3922 composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1); 3923 if (element.hasDisplayElement()) 3924 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 3925 for (int i = 0; i < element.getTarget().size(); i++) 3926 composeConceptMapTargetElementComponent(t, "ConceptMap", "target", element.getTarget().get(i), i); 3927 } 3928 3929 protected void composeConceptMapTargetElementComponent(Complex parent, String parentType, String name, ConceptMap.TargetElementComponent element, int index) { 3930 if (element == null) 3931 return; 3932 Complex t; 3933 if (Utilities.noString(parentType)) 3934 t = parent; 3935 else { 3936 t = parent.predicate("fhir:"+parentType+'.'+name); 3937 } 3938 composeBackboneElement(t, "target", name, element, index); 3939 if (element.hasCodeElement()) 3940 composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1); 3941 if (element.hasDisplayElement()) 3942 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 3943 if (element.hasEquivalenceElement()) 3944 composeEnum(t, "ConceptMap", "equivalence", element.getEquivalenceElement(), -1); 3945 if (element.hasCommentElement()) 3946 composeString(t, "ConceptMap", "comment", element.getCommentElement(), -1); 3947 for (int i = 0; i < element.getDependsOn().size(); i++) 3948 composeConceptMapOtherElementComponent(t, "ConceptMap", "dependsOn", element.getDependsOn().get(i), i); 3949 for (int i = 0; i < element.getProduct().size(); i++) 3950 composeConceptMapOtherElementComponent(t, "ConceptMap", "product", element.getProduct().get(i), i); 3951 } 3952 3953 protected void composeConceptMapOtherElementComponent(Complex parent, String parentType, String name, ConceptMap.OtherElementComponent element, int index) { 3954 if (element == null) 3955 return; 3956 Complex t; 3957 if (Utilities.noString(parentType)) 3958 t = parent; 3959 else { 3960 t = parent.predicate("fhir:"+parentType+'.'+name); 3961 } 3962 composeBackboneElement(t, "dependsOn", name, element, index); 3963 if (element.hasPropertyElement()) 3964 composeUri(t, "ConceptMap", "property", element.getPropertyElement(), -1); 3965 if (element.hasSystemElement()) 3966 composeUri(t, "ConceptMap", "system", element.getSystemElement(), -1); 3967 if (element.hasCodeElement()) 3968 composeString(t, "ConceptMap", "code", element.getCodeElement(), -1); 3969 if (element.hasDisplayElement()) 3970 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 3971 } 3972 3973 protected void composeConceptMapConceptMapGroupUnmappedComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupUnmappedComponent element, int index) { 3974 if (element == null) 3975 return; 3976 Complex t; 3977 if (Utilities.noString(parentType)) 3978 t = parent; 3979 else { 3980 t = parent.predicate("fhir:"+parentType+'.'+name); 3981 } 3982 composeBackboneElement(t, "unmapped", name, element, index); 3983 if (element.hasModeElement()) 3984 composeEnum(t, "ConceptMap", "mode", element.getModeElement(), -1); 3985 if (element.hasCodeElement()) 3986 composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1); 3987 if (element.hasDisplayElement()) 3988 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 3989 if (element.hasUrlElement()) 3990 composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1); 3991 } 3992 3993 protected void composeCondition(Complex parent, String parentType, String name, Condition element, int index) { 3994 if (element == null) 3995 return; 3996 Complex t; 3997 if (Utilities.noString(parentType)) 3998 t = parent; 3999 else { 4000 t = parent.predicate("fhir:"+parentType+'.'+name); 4001 } 4002 composeDomainResource(t, "Condition", name, element, index); 4003 for (int i = 0; i < element.getIdentifier().size(); i++) 4004 composeIdentifier(t, "Condition", "identifier", element.getIdentifier().get(i), i); 4005 if (element.hasClinicalStatusElement()) 4006 composeEnum(t, "Condition", "clinicalStatus", element.getClinicalStatusElement(), -1); 4007 if (element.hasVerificationStatusElement()) 4008 composeEnum(t, "Condition", "verificationStatus", element.getVerificationStatusElement(), -1); 4009 for (int i = 0; i < element.getCategory().size(); i++) 4010 composeCodeableConcept(t, "Condition", "category", element.getCategory().get(i), i); 4011 if (element.hasSeverity()) 4012 composeCodeableConcept(t, "Condition", "severity", element.getSeverity(), -1); 4013 if (element.hasCode()) 4014 composeCodeableConcept(t, "Condition", "code", element.getCode(), -1); 4015 for (int i = 0; i < element.getBodySite().size(); i++) 4016 composeCodeableConcept(t, "Condition", "bodySite", element.getBodySite().get(i), i); 4017 if (element.hasSubject()) 4018 composeReference(t, "Condition", "subject", element.getSubject(), -1); 4019 if (element.hasContext()) 4020 composeReference(t, "Condition", "context", element.getContext(), -1); 4021 if (element.hasOnset()) 4022 composeType(t, "Condition", "onset", element.getOnset(), -1); 4023 if (element.hasAbatement()) 4024 composeType(t, "Condition", "abatement", element.getAbatement(), -1); 4025 if (element.hasAssertedDateElement()) 4026 composeDateTime(t, "Condition", "assertedDate", element.getAssertedDateElement(), -1); 4027 if (element.hasAsserter()) 4028 composeReference(t, "Condition", "asserter", element.getAsserter(), -1); 4029 if (element.hasStage()) 4030 composeConditionConditionStageComponent(t, "Condition", "stage", element.getStage(), -1); 4031 for (int i = 0; i < element.getEvidence().size(); i++) 4032 composeConditionConditionEvidenceComponent(t, "Condition", "evidence", element.getEvidence().get(i), i); 4033 for (int i = 0; i < element.getNote().size(); i++) 4034 composeAnnotation(t, "Condition", "note", element.getNote().get(i), i); 4035 } 4036 4037 protected void composeConditionConditionStageComponent(Complex parent, String parentType, String name, Condition.ConditionStageComponent element, int index) { 4038 if (element == null) 4039 return; 4040 Complex t; 4041 if (Utilities.noString(parentType)) 4042 t = parent; 4043 else { 4044 t = parent.predicate("fhir:"+parentType+'.'+name); 4045 } 4046 composeBackboneElement(t, "stage", name, element, index); 4047 if (element.hasSummary()) 4048 composeCodeableConcept(t, "Condition", "summary", element.getSummary(), -1); 4049 for (int i = 0; i < element.getAssessment().size(); i++) 4050 composeReference(t, "Condition", "assessment", element.getAssessment().get(i), i); 4051 } 4052 4053 protected void composeConditionConditionEvidenceComponent(Complex parent, String parentType, String name, Condition.ConditionEvidenceComponent element, int index) { 4054 if (element == null) 4055 return; 4056 Complex t; 4057 if (Utilities.noString(parentType)) 4058 t = parent; 4059 else { 4060 t = parent.predicate("fhir:"+parentType+'.'+name); 4061 } 4062 composeBackboneElement(t, "evidence", name, element, index); 4063 for (int i = 0; i < element.getCode().size(); i++) 4064 composeCodeableConcept(t, "Condition", "code", element.getCode().get(i), i); 4065 for (int i = 0; i < element.getDetail().size(); i++) 4066 composeReference(t, "Condition", "detail", element.getDetail().get(i), i); 4067 } 4068 4069 protected void composeConsent(Complex parent, String parentType, String name, Consent element, int index) { 4070 if (element == null) 4071 return; 4072 Complex t; 4073 if (Utilities.noString(parentType)) 4074 t = parent; 4075 else { 4076 t = parent.predicate("fhir:"+parentType+'.'+name); 4077 } 4078 composeDomainResource(t, "Consent", name, element, index); 4079 if (element.hasIdentifier()) 4080 composeIdentifier(t, "Consent", "identifier", element.getIdentifier(), -1); 4081 if (element.hasStatusElement()) 4082 composeEnum(t, "Consent", "status", element.getStatusElement(), -1); 4083 for (int i = 0; i < element.getCategory().size(); i++) 4084 composeCodeableConcept(t, "Consent", "category", element.getCategory().get(i), i); 4085 if (element.hasPatient()) 4086 composeReference(t, "Consent", "patient", element.getPatient(), -1); 4087 if (element.hasPeriod()) 4088 composePeriod(t, "Consent", "period", element.getPeriod(), -1); 4089 if (element.hasDateTimeElement()) 4090 composeDateTime(t, "Consent", "dateTime", element.getDateTimeElement(), -1); 4091 for (int i = 0; i < element.getConsentingParty().size(); i++) 4092 composeReference(t, "Consent", "consentingParty", element.getConsentingParty().get(i), i); 4093 for (int i = 0; i < element.getActor().size(); i++) 4094 composeConsentConsentActorComponent(t, "Consent", "actor", element.getActor().get(i), i); 4095 for (int i = 0; i < element.getAction().size(); i++) 4096 composeCodeableConcept(t, "Consent", "action", element.getAction().get(i), i); 4097 for (int i = 0; i < element.getOrganization().size(); i++) 4098 composeReference(t, "Consent", "organization", element.getOrganization().get(i), i); 4099 if (element.hasSource()) 4100 composeType(t, "Consent", "source", element.getSource(), -1); 4101 for (int i = 0; i < element.getPolicy().size(); i++) 4102 composeConsentConsentPolicyComponent(t, "Consent", "policy", element.getPolicy().get(i), i); 4103 if (element.hasPolicyRuleElement()) 4104 composeUri(t, "Consent", "policyRule", element.getPolicyRuleElement(), -1); 4105 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4106 composeCoding(t, "Consent", "securityLabel", element.getSecurityLabel().get(i), i); 4107 for (int i = 0; i < element.getPurpose().size(); i++) 4108 composeCoding(t, "Consent", "purpose", element.getPurpose().get(i), i); 4109 if (element.hasDataPeriod()) 4110 composePeriod(t, "Consent", "dataPeriod", element.getDataPeriod(), -1); 4111 for (int i = 0; i < element.getData().size(); i++) 4112 composeConsentConsentDataComponent(t, "Consent", "data", element.getData().get(i), i); 4113 for (int i = 0; i < element.getExcept().size(); i++) 4114 composeConsentExceptComponent(t, "Consent", "except", element.getExcept().get(i), i); 4115 } 4116 4117 protected void composeConsentConsentActorComponent(Complex parent, String parentType, String name, Consent.ConsentActorComponent element, int index) { 4118 if (element == null) 4119 return; 4120 Complex t; 4121 if (Utilities.noString(parentType)) 4122 t = parent; 4123 else { 4124 t = parent.predicate("fhir:"+parentType+'.'+name); 4125 } 4126 composeBackboneElement(t, "actor", name, element, index); 4127 if (element.hasRole()) 4128 composeCodeableConcept(t, "Consent", "role", element.getRole(), -1); 4129 if (element.hasReference()) 4130 composeReference(t, "Consent", "reference", element.getReference(), -1); 4131 } 4132 4133 protected void composeConsentConsentPolicyComponent(Complex parent, String parentType, String name, Consent.ConsentPolicyComponent element, int index) { 4134 if (element == null) 4135 return; 4136 Complex t; 4137 if (Utilities.noString(parentType)) 4138 t = parent; 4139 else { 4140 t = parent.predicate("fhir:"+parentType+'.'+name); 4141 } 4142 composeBackboneElement(t, "policy", name, element, index); 4143 if (element.hasAuthorityElement()) 4144 composeUri(t, "Consent", "authority", element.getAuthorityElement(), -1); 4145 if (element.hasUriElement()) 4146 composeUri(t, "Consent", "uri", element.getUriElement(), -1); 4147 } 4148 4149 protected void composeConsentConsentDataComponent(Complex parent, String parentType, String name, Consent.ConsentDataComponent element, int index) { 4150 if (element == null) 4151 return; 4152 Complex t; 4153 if (Utilities.noString(parentType)) 4154 t = parent; 4155 else { 4156 t = parent.predicate("fhir:"+parentType+'.'+name); 4157 } 4158 composeBackboneElement(t, "data", name, element, index); 4159 if (element.hasMeaningElement()) 4160 composeEnum(t, "Consent", "meaning", element.getMeaningElement(), -1); 4161 if (element.hasReference()) 4162 composeReference(t, "Consent", "reference", element.getReference(), -1); 4163 } 4164 4165 protected void composeConsentExceptComponent(Complex parent, String parentType, String name, Consent.ExceptComponent element, int index) { 4166 if (element == null) 4167 return; 4168 Complex t; 4169 if (Utilities.noString(parentType)) 4170 t = parent; 4171 else { 4172 t = parent.predicate("fhir:"+parentType+'.'+name); 4173 } 4174 composeBackboneElement(t, "except", name, element, index); 4175 if (element.hasTypeElement()) 4176 composeEnum(t, "Consent", "type", element.getTypeElement(), -1); 4177 if (element.hasPeriod()) 4178 composePeriod(t, "Consent", "period", element.getPeriod(), -1); 4179 for (int i = 0; i < element.getActor().size(); i++) 4180 composeConsentExceptActorComponent(t, "Consent", "actor", element.getActor().get(i), i); 4181 for (int i = 0; i < element.getAction().size(); i++) 4182 composeCodeableConcept(t, "Consent", "action", element.getAction().get(i), i); 4183 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4184 composeCoding(t, "Consent", "securityLabel", element.getSecurityLabel().get(i), i); 4185 for (int i = 0; i < element.getPurpose().size(); i++) 4186 composeCoding(t, "Consent", "purpose", element.getPurpose().get(i), i); 4187 for (int i = 0; i < element.getClass_().size(); i++) 4188 composeCoding(t, "Consent", "class", element.getClass_().get(i), i); 4189 for (int i = 0; i < element.getCode().size(); i++) 4190 composeCoding(t, "Consent", "code", element.getCode().get(i), i); 4191 if (element.hasDataPeriod()) 4192 composePeriod(t, "Consent", "dataPeriod", element.getDataPeriod(), -1); 4193 for (int i = 0; i < element.getData().size(); i++) 4194 composeConsentExceptDataComponent(t, "Consent", "data", element.getData().get(i), i); 4195 } 4196 4197 protected void composeConsentExceptActorComponent(Complex parent, String parentType, String name, Consent.ExceptActorComponent element, int index) { 4198 if (element == null) 4199 return; 4200 Complex t; 4201 if (Utilities.noString(parentType)) 4202 t = parent; 4203 else { 4204 t = parent.predicate("fhir:"+parentType+'.'+name); 4205 } 4206 composeBackboneElement(t, "actor", name, element, index); 4207 if (element.hasRole()) 4208 composeCodeableConcept(t, "Consent", "role", element.getRole(), -1); 4209 if (element.hasReference()) 4210 composeReference(t, "Consent", "reference", element.getReference(), -1); 4211 } 4212 4213 protected void composeConsentExceptDataComponent(Complex parent, String parentType, String name, Consent.ExceptDataComponent element, int index) { 4214 if (element == null) 4215 return; 4216 Complex t; 4217 if (Utilities.noString(parentType)) 4218 t = parent; 4219 else { 4220 t = parent.predicate("fhir:"+parentType+'.'+name); 4221 } 4222 composeBackboneElement(t, "data", name, element, index); 4223 if (element.hasMeaningElement()) 4224 composeEnum(t, "Consent", "meaning", element.getMeaningElement(), -1); 4225 if (element.hasReference()) 4226 composeReference(t, "Consent", "reference", element.getReference(), -1); 4227 } 4228 4229 protected void composeContract(Complex parent, String parentType, String name, Contract element, int index) { 4230 if (element == null) 4231 return; 4232 Complex t; 4233 if (Utilities.noString(parentType)) 4234 t = parent; 4235 else { 4236 t = parent.predicate("fhir:"+parentType+'.'+name); 4237 } 4238 composeDomainResource(t, "Contract", name, element, index); 4239 if (element.hasIdentifier()) 4240 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 4241 if (element.hasStatusElement()) 4242 composeEnum(t, "Contract", "status", element.getStatusElement(), -1); 4243 if (element.hasIssuedElement()) 4244 composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1); 4245 if (element.hasApplies()) 4246 composePeriod(t, "Contract", "applies", element.getApplies(), -1); 4247 for (int i = 0; i < element.getSubject().size(); i++) 4248 composeReference(t, "Contract", "subject", element.getSubject().get(i), i); 4249 for (int i = 0; i < element.getTopic().size(); i++) 4250 composeReference(t, "Contract", "topic", element.getTopic().get(i), i); 4251 for (int i = 0; i < element.getAuthority().size(); i++) 4252 composeReference(t, "Contract", "authority", element.getAuthority().get(i), i); 4253 for (int i = 0; i < element.getDomain().size(); i++) 4254 composeReference(t, "Contract", "domain", element.getDomain().get(i), i); 4255 if (element.hasType()) 4256 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 4257 for (int i = 0; i < element.getSubType().size(); i++) 4258 composeCodeableConcept(t, "Contract", "subType", element.getSubType().get(i), i); 4259 for (int i = 0; i < element.getAction().size(); i++) 4260 composeCodeableConcept(t, "Contract", "action", element.getAction().get(i), i); 4261 for (int i = 0; i < element.getActionReason().size(); i++) 4262 composeCodeableConcept(t, "Contract", "actionReason", element.getActionReason().get(i), i); 4263 if (element.hasDecisionType()) 4264 composeCodeableConcept(t, "Contract", "decisionType", element.getDecisionType(), -1); 4265 if (element.hasContentDerivative()) 4266 composeCodeableConcept(t, "Contract", "contentDerivative", element.getContentDerivative(), -1); 4267 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4268 composeCoding(t, "Contract", "securityLabel", element.getSecurityLabel().get(i), i); 4269 for (int i = 0; i < element.getAgent().size(); i++) 4270 composeContractAgentComponent(t, "Contract", "agent", element.getAgent().get(i), i); 4271 for (int i = 0; i < element.getSigner().size(); i++) 4272 composeContractSignatoryComponent(t, "Contract", "signer", element.getSigner().get(i), i); 4273 for (int i = 0; i < element.getValuedItem().size(); i++) 4274 composeContractValuedItemComponent(t, "Contract", "valuedItem", element.getValuedItem().get(i), i); 4275 for (int i = 0; i < element.getTerm().size(); i++) 4276 composeContractTermComponent(t, "Contract", "term", element.getTerm().get(i), i); 4277 if (element.hasBinding()) 4278 composeType(t, "Contract", "binding", element.getBinding(), -1); 4279 for (int i = 0; i < element.getFriendly().size(); i++) 4280 composeContractFriendlyLanguageComponent(t, "Contract", "friendly", element.getFriendly().get(i), i); 4281 for (int i = 0; i < element.getLegal().size(); i++) 4282 composeContractLegalLanguageComponent(t, "Contract", "legal", element.getLegal().get(i), i); 4283 for (int i = 0; i < element.getRule().size(); i++) 4284 composeContractComputableLanguageComponent(t, "Contract", "rule", element.getRule().get(i), i); 4285 } 4286 4287 protected void composeContractAgentComponent(Complex parent, String parentType, String name, Contract.AgentComponent element, int index) { 4288 if (element == null) 4289 return; 4290 Complex t; 4291 if (Utilities.noString(parentType)) 4292 t = parent; 4293 else { 4294 t = parent.predicate("fhir:"+parentType+'.'+name); 4295 } 4296 composeBackboneElement(t, "agent", name, element, index); 4297 if (element.hasActor()) 4298 composeReference(t, "Contract", "actor", element.getActor(), -1); 4299 for (int i = 0; i < element.getRole().size(); i++) 4300 composeCodeableConcept(t, "Contract", "role", element.getRole().get(i), i); 4301 } 4302 4303 protected void composeContractSignatoryComponent(Complex parent, String parentType, String name, Contract.SignatoryComponent element, int index) { 4304 if (element == null) 4305 return; 4306 Complex t; 4307 if (Utilities.noString(parentType)) 4308 t = parent; 4309 else { 4310 t = parent.predicate("fhir:"+parentType+'.'+name); 4311 } 4312 composeBackboneElement(t, "signer", name, element, index); 4313 if (element.hasType()) 4314 composeCoding(t, "Contract", "type", element.getType(), -1); 4315 if (element.hasParty()) 4316 composeReference(t, "Contract", "party", element.getParty(), -1); 4317 for (int i = 0; i < element.getSignature().size(); i++) 4318 composeSignature(t, "Contract", "signature", element.getSignature().get(i), i); 4319 } 4320 4321 protected void composeContractValuedItemComponent(Complex parent, String parentType, String name, Contract.ValuedItemComponent element, int index) { 4322 if (element == null) 4323 return; 4324 Complex t; 4325 if (Utilities.noString(parentType)) 4326 t = parent; 4327 else { 4328 t = parent.predicate("fhir:"+parentType+'.'+name); 4329 } 4330 composeBackboneElement(t, "valuedItem", name, element, index); 4331 if (element.hasEntity()) 4332 composeType(t, "Contract", "entity", element.getEntity(), -1); 4333 if (element.hasIdentifier()) 4334 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 4335 if (element.hasEffectiveTimeElement()) 4336 composeDateTime(t, "Contract", "effectiveTime", element.getEffectiveTimeElement(), -1); 4337 if (element.hasQuantity()) 4338 composeQuantity(t, "Contract", "quantity", element.getQuantity(), -1); 4339 if (element.hasUnitPrice()) 4340 composeMoney(t, "Contract", "unitPrice", element.getUnitPrice(), -1); 4341 if (element.hasFactorElement()) 4342 composeDecimal(t, "Contract", "factor", element.getFactorElement(), -1); 4343 if (element.hasPointsElement()) 4344 composeDecimal(t, "Contract", "points", element.getPointsElement(), -1); 4345 if (element.hasNet()) 4346 composeMoney(t, "Contract", "net", element.getNet(), -1); 4347 } 4348 4349 protected void composeContractTermComponent(Complex parent, String parentType, String name, Contract.TermComponent element, int index) { 4350 if (element == null) 4351 return; 4352 Complex t; 4353 if (Utilities.noString(parentType)) 4354 t = parent; 4355 else { 4356 t = parent.predicate("fhir:"+parentType+'.'+name); 4357 } 4358 composeBackboneElement(t, "term", name, element, index); 4359 if (element.hasIdentifier()) 4360 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 4361 if (element.hasIssuedElement()) 4362 composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1); 4363 if (element.hasApplies()) 4364 composePeriod(t, "Contract", "applies", element.getApplies(), -1); 4365 if (element.hasType()) 4366 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 4367 if (element.hasSubType()) 4368 composeCodeableConcept(t, "Contract", "subType", element.getSubType(), -1); 4369 for (int i = 0; i < element.getTopic().size(); i++) 4370 composeReference(t, "Contract", "topic", element.getTopic().get(i), i); 4371 for (int i = 0; i < element.getAction().size(); i++) 4372 composeCodeableConcept(t, "Contract", "action", element.getAction().get(i), i); 4373 for (int i = 0; i < element.getActionReason().size(); i++) 4374 composeCodeableConcept(t, "Contract", "actionReason", element.getActionReason().get(i), i); 4375 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4376 composeCoding(t, "Contract", "securityLabel", element.getSecurityLabel().get(i), i); 4377 for (int i = 0; i < element.getAgent().size(); i++) 4378 composeContractTermAgentComponent(t, "Contract", "agent", element.getAgent().get(i), i); 4379 if (element.hasTextElement()) 4380 composeString(t, "Contract", "text", element.getTextElement(), -1); 4381 for (int i = 0; i < element.getValuedItem().size(); i++) 4382 composeContractTermValuedItemComponent(t, "Contract", "valuedItem", element.getValuedItem().get(i), i); 4383 for (int i = 0; i < element.getGroup().size(); i++) 4384 composeContractTermComponent(t, "Contract", "group", element.getGroup().get(i), i); 4385 } 4386 4387 protected void composeContractTermAgentComponent(Complex parent, String parentType, String name, Contract.TermAgentComponent element, int index) { 4388 if (element == null) 4389 return; 4390 Complex t; 4391 if (Utilities.noString(parentType)) 4392 t = parent; 4393 else { 4394 t = parent.predicate("fhir:"+parentType+'.'+name); 4395 } 4396 composeBackboneElement(t, "agent", name, element, index); 4397 if (element.hasActor()) 4398 composeReference(t, "Contract", "actor", element.getActor(), -1); 4399 for (int i = 0; i < element.getRole().size(); i++) 4400 composeCodeableConcept(t, "Contract", "role", element.getRole().get(i), i); 4401 } 4402 4403 protected void composeContractTermValuedItemComponent(Complex parent, String parentType, String name, Contract.TermValuedItemComponent element, int index) { 4404 if (element == null) 4405 return; 4406 Complex t; 4407 if (Utilities.noString(parentType)) 4408 t = parent; 4409 else { 4410 t = parent.predicate("fhir:"+parentType+'.'+name); 4411 } 4412 composeBackboneElement(t, "valuedItem", name, element, index); 4413 if (element.hasEntity()) 4414 composeType(t, "Contract", "entity", element.getEntity(), -1); 4415 if (element.hasIdentifier()) 4416 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 4417 if (element.hasEffectiveTimeElement()) 4418 composeDateTime(t, "Contract", "effectiveTime", element.getEffectiveTimeElement(), -1); 4419 if (element.hasQuantity()) 4420 composeQuantity(t, "Contract", "quantity", element.getQuantity(), -1); 4421 if (element.hasUnitPrice()) 4422 composeMoney(t, "Contract", "unitPrice", element.getUnitPrice(), -1); 4423 if (element.hasFactorElement()) 4424 composeDecimal(t, "Contract", "factor", element.getFactorElement(), -1); 4425 if (element.hasPointsElement()) 4426 composeDecimal(t, "Contract", "points", element.getPointsElement(), -1); 4427 if (element.hasNet()) 4428 composeMoney(t, "Contract", "net", element.getNet(), -1); 4429 } 4430 4431 protected void composeContractFriendlyLanguageComponent(Complex parent, String parentType, String name, Contract.FriendlyLanguageComponent element, int index) { 4432 if (element == null) 4433 return; 4434 Complex t; 4435 if (Utilities.noString(parentType)) 4436 t = parent; 4437 else { 4438 t = parent.predicate("fhir:"+parentType+'.'+name); 4439 } 4440 composeBackboneElement(t, "friendly", name, element, index); 4441 if (element.hasContent()) 4442 composeType(t, "Contract", "content", element.getContent(), -1); 4443 } 4444 4445 protected void composeContractLegalLanguageComponent(Complex parent, String parentType, String name, Contract.LegalLanguageComponent element, int index) { 4446 if (element == null) 4447 return; 4448 Complex t; 4449 if (Utilities.noString(parentType)) 4450 t = parent; 4451 else { 4452 t = parent.predicate("fhir:"+parentType+'.'+name); 4453 } 4454 composeBackboneElement(t, "legal", name, element, index); 4455 if (element.hasContent()) 4456 composeType(t, "Contract", "content", element.getContent(), -1); 4457 } 4458 4459 protected void composeContractComputableLanguageComponent(Complex parent, String parentType, String name, Contract.ComputableLanguageComponent element, int index) { 4460 if (element == null) 4461 return; 4462 Complex t; 4463 if (Utilities.noString(parentType)) 4464 t = parent; 4465 else { 4466 t = parent.predicate("fhir:"+parentType+'.'+name); 4467 } 4468 composeBackboneElement(t, "rule", name, element, index); 4469 if (element.hasContent()) 4470 composeType(t, "Contract", "content", element.getContent(), -1); 4471 } 4472 4473 protected void composeCoverage(Complex parent, String parentType, String name, Coverage element, int index) { 4474 if (element == null) 4475 return; 4476 Complex t; 4477 if (Utilities.noString(parentType)) 4478 t = parent; 4479 else { 4480 t = parent.predicate("fhir:"+parentType+'.'+name); 4481 } 4482 composeDomainResource(t, "Coverage", name, element, index); 4483 for (int i = 0; i < element.getIdentifier().size(); i++) 4484 composeIdentifier(t, "Coverage", "identifier", element.getIdentifier().get(i), i); 4485 if (element.hasStatusElement()) 4486 composeEnum(t, "Coverage", "status", element.getStatusElement(), -1); 4487 if (element.hasType()) 4488 composeCodeableConcept(t, "Coverage", "type", element.getType(), -1); 4489 if (element.hasPolicyHolder()) 4490 composeReference(t, "Coverage", "policyHolder", element.getPolicyHolder(), -1); 4491 if (element.hasSubscriber()) 4492 composeReference(t, "Coverage", "subscriber", element.getSubscriber(), -1); 4493 if (element.hasSubscriberIdElement()) 4494 composeString(t, "Coverage", "subscriberId", element.getSubscriberIdElement(), -1); 4495 if (element.hasBeneficiary()) 4496 composeReference(t, "Coverage", "beneficiary", element.getBeneficiary(), -1); 4497 if (element.hasRelationship()) 4498 composeCodeableConcept(t, "Coverage", "relationship", element.getRelationship(), -1); 4499 if (element.hasPeriod()) 4500 composePeriod(t, "Coverage", "period", element.getPeriod(), -1); 4501 for (int i = 0; i < element.getPayor().size(); i++) 4502 composeReference(t, "Coverage", "payor", element.getPayor().get(i), i); 4503 if (element.hasGrouping()) 4504 composeCoverageGroupComponent(t, "Coverage", "grouping", element.getGrouping(), -1); 4505 if (element.hasDependentElement()) 4506 composeString(t, "Coverage", "dependent", element.getDependentElement(), -1); 4507 if (element.hasSequenceElement()) 4508 composeString(t, "Coverage", "sequence", element.getSequenceElement(), -1); 4509 if (element.hasOrderElement()) 4510 composePositiveInt(t, "Coverage", "order", element.getOrderElement(), -1); 4511 if (element.hasNetworkElement()) 4512 composeString(t, "Coverage", "network", element.getNetworkElement(), -1); 4513 for (int i = 0; i < element.getContract().size(); i++) 4514 composeReference(t, "Coverage", "contract", element.getContract().get(i), i); 4515 } 4516 4517 protected void composeCoverageGroupComponent(Complex parent, String parentType, String name, Coverage.GroupComponent element, int index) { 4518 if (element == null) 4519 return; 4520 Complex t; 4521 if (Utilities.noString(parentType)) 4522 t = parent; 4523 else { 4524 t = parent.predicate("fhir:"+parentType+'.'+name); 4525 } 4526 composeBackboneElement(t, "grouping", name, element, index); 4527 if (element.hasGroupElement()) 4528 composeString(t, "Coverage", "group", element.getGroupElement(), -1); 4529 if (element.hasGroupDisplayElement()) 4530 composeString(t, "Coverage", "groupDisplay", element.getGroupDisplayElement(), -1); 4531 if (element.hasSubGroupElement()) 4532 composeString(t, "Coverage", "subGroup", element.getSubGroupElement(), -1); 4533 if (element.hasSubGroupDisplayElement()) 4534 composeString(t, "Coverage", "subGroupDisplay", element.getSubGroupDisplayElement(), -1); 4535 if (element.hasPlanElement()) 4536 composeString(t, "Coverage", "plan", element.getPlanElement(), -1); 4537 if (element.hasPlanDisplayElement()) 4538 composeString(t, "Coverage", "planDisplay", element.getPlanDisplayElement(), -1); 4539 if (element.hasSubPlanElement()) 4540 composeString(t, "Coverage", "subPlan", element.getSubPlanElement(), -1); 4541 if (element.hasSubPlanDisplayElement()) 4542 composeString(t, "Coverage", "subPlanDisplay", element.getSubPlanDisplayElement(), -1); 4543 if (element.hasClass_Element()) 4544 composeString(t, "Coverage", "class", element.getClass_Element(), -1); 4545 if (element.hasClassDisplayElement()) 4546 composeString(t, "Coverage", "classDisplay", element.getClassDisplayElement(), -1); 4547 if (element.hasSubClassElement()) 4548 composeString(t, "Coverage", "subClass", element.getSubClassElement(), -1); 4549 if (element.hasSubClassDisplayElement()) 4550 composeString(t, "Coverage", "subClassDisplay", element.getSubClassDisplayElement(), -1); 4551 } 4552 4553 protected void composeDataElement(Complex parent, String parentType, String name, DataElement element, int index) { 4554 if (element == null) 4555 return; 4556 Complex t; 4557 if (Utilities.noString(parentType)) 4558 t = parent; 4559 else { 4560 t = parent.predicate("fhir:"+parentType+'.'+name); 4561 } 4562 composeDomainResource(t, "DataElement", name, element, index); 4563 if (element.hasUrlElement()) 4564 composeUri(t, "DataElement", "url", element.getUrlElement(), -1); 4565 for (int i = 0; i < element.getIdentifier().size(); i++) 4566 composeIdentifier(t, "DataElement", "identifier", element.getIdentifier().get(i), i); 4567 if (element.hasVersionElement()) 4568 composeString(t, "DataElement", "version", element.getVersionElement(), -1); 4569 if (element.hasStatusElement()) 4570 composeEnum(t, "DataElement", "status", element.getStatusElement(), -1); 4571 if (element.hasExperimentalElement()) 4572 composeBoolean(t, "DataElement", "experimental", element.getExperimentalElement(), -1); 4573 if (element.hasDateElement()) 4574 composeDateTime(t, "DataElement", "date", element.getDateElement(), -1); 4575 if (element.hasPublisherElement()) 4576 composeString(t, "DataElement", "publisher", element.getPublisherElement(), -1); 4577 if (element.hasNameElement()) 4578 composeString(t, "DataElement", "name", element.getNameElement(), -1); 4579 if (element.hasTitleElement()) 4580 composeString(t, "DataElement", "title", element.getTitleElement(), -1); 4581 for (int i = 0; i < element.getContact().size(); i++) 4582 composeContactDetail(t, "DataElement", "contact", element.getContact().get(i), i); 4583 for (int i = 0; i < element.getUseContext().size(); i++) 4584 composeUsageContext(t, "DataElement", "useContext", element.getUseContext().get(i), i); 4585 for (int i = 0; i < element.getJurisdiction().size(); i++) 4586 composeCodeableConcept(t, "DataElement", "jurisdiction", element.getJurisdiction().get(i), i); 4587 if (element.hasCopyrightElement()) 4588 composeMarkdown(t, "DataElement", "copyright", element.getCopyrightElement(), -1); 4589 if (element.hasStringencyElement()) 4590 composeEnum(t, "DataElement", "stringency", element.getStringencyElement(), -1); 4591 for (int i = 0; i < element.getMapping().size(); i++) 4592 composeDataElementDataElementMappingComponent(t, "DataElement", "mapping", element.getMapping().get(i), i); 4593 for (int i = 0; i < element.getElement().size(); i++) 4594 composeElementDefinition(t, "DataElement", "element", element.getElement().get(i), i); 4595 } 4596 4597 protected void composeDataElementDataElementMappingComponent(Complex parent, String parentType, String name, DataElement.DataElementMappingComponent element, int index) { 4598 if (element == null) 4599 return; 4600 Complex t; 4601 if (Utilities.noString(parentType)) 4602 t = parent; 4603 else { 4604 t = parent.predicate("fhir:"+parentType+'.'+name); 4605 } 4606 composeBackboneElement(t, "mapping", name, element, index); 4607 if (element.hasIdentityElement()) 4608 composeId(t, "DataElement", "identity", element.getIdentityElement(), -1); 4609 if (element.hasUriElement()) 4610 composeUri(t, "DataElement", "uri", element.getUriElement(), -1); 4611 if (element.hasNameElement()) 4612 composeString(t, "DataElement", "name", element.getNameElement(), -1); 4613 if (element.hasCommentElement()) 4614 composeString(t, "DataElement", "comment", element.getCommentElement(), -1); 4615 } 4616 4617 protected void composeDetectedIssue(Complex parent, String parentType, String name, DetectedIssue element, int index) { 4618 if (element == null) 4619 return; 4620 Complex t; 4621 if (Utilities.noString(parentType)) 4622 t = parent; 4623 else { 4624 t = parent.predicate("fhir:"+parentType+'.'+name); 4625 } 4626 composeDomainResource(t, "DetectedIssue", name, element, index); 4627 if (element.hasIdentifier()) 4628 composeIdentifier(t, "DetectedIssue", "identifier", element.getIdentifier(), -1); 4629 if (element.hasStatusElement()) 4630 composeEnum(t, "DetectedIssue", "status", element.getStatusElement(), -1); 4631 if (element.hasCategory()) 4632 composeCodeableConcept(t, "DetectedIssue", "category", element.getCategory(), -1); 4633 if (element.hasSeverityElement()) 4634 composeEnum(t, "DetectedIssue", "severity", element.getSeverityElement(), -1); 4635 if (element.hasPatient()) 4636 composeReference(t, "DetectedIssue", "patient", element.getPatient(), -1); 4637 if (element.hasDateElement()) 4638 composeDateTime(t, "DetectedIssue", "date", element.getDateElement(), -1); 4639 if (element.hasAuthor()) 4640 composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1); 4641 for (int i = 0; i < element.getImplicated().size(); i++) 4642 composeReference(t, "DetectedIssue", "implicated", element.getImplicated().get(i), i); 4643 if (element.hasDetailElement()) 4644 composeString(t, "DetectedIssue", "detail", element.getDetailElement(), -1); 4645 if (element.hasReferenceElement()) 4646 composeUri(t, "DetectedIssue", "reference", element.getReferenceElement(), -1); 4647 for (int i = 0; i < element.getMitigation().size(); i++) 4648 composeDetectedIssueDetectedIssueMitigationComponent(t, "DetectedIssue", "mitigation", element.getMitigation().get(i), i); 4649 } 4650 4651 protected void composeDetectedIssueDetectedIssueMitigationComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueMitigationComponent element, int index) { 4652 if (element == null) 4653 return; 4654 Complex t; 4655 if (Utilities.noString(parentType)) 4656 t = parent; 4657 else { 4658 t = parent.predicate("fhir:"+parentType+'.'+name); 4659 } 4660 composeBackboneElement(t, "mitigation", name, element, index); 4661 if (element.hasAction()) 4662 composeCodeableConcept(t, "DetectedIssue", "action", element.getAction(), -1); 4663 if (element.hasDateElement()) 4664 composeDateTime(t, "DetectedIssue", "date", element.getDateElement(), -1); 4665 if (element.hasAuthor()) 4666 composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1); 4667 } 4668 4669 protected void composeDevice(Complex parent, String parentType, String name, Device element, int index) { 4670 if (element == null) 4671 return; 4672 Complex t; 4673 if (Utilities.noString(parentType)) 4674 t = parent; 4675 else { 4676 t = parent.predicate("fhir:"+parentType+'.'+name); 4677 } 4678 composeDomainResource(t, "Device", name, element, index); 4679 for (int i = 0; i < element.getIdentifier().size(); i++) 4680 composeIdentifier(t, "Device", "identifier", element.getIdentifier().get(i), i); 4681 if (element.hasUdi()) 4682 composeDeviceDeviceUdiComponent(t, "Device", "udi", element.getUdi(), -1); 4683 if (element.hasStatusElement()) 4684 composeEnum(t, "Device", "status", element.getStatusElement(), -1); 4685 if (element.hasType()) 4686 composeCodeableConcept(t, "Device", "type", element.getType(), -1); 4687 if (element.hasLotNumberElement()) 4688 composeString(t, "Device", "lotNumber", element.getLotNumberElement(), -1); 4689 if (element.hasManufacturerElement()) 4690 composeString(t, "Device", "manufacturer", element.getManufacturerElement(), -1); 4691 if (element.hasManufactureDateElement()) 4692 composeDateTime(t, "Device", "manufactureDate", element.getManufactureDateElement(), -1); 4693 if (element.hasExpirationDateElement()) 4694 composeDateTime(t, "Device", "expirationDate", element.getExpirationDateElement(), -1); 4695 if (element.hasModelElement()) 4696 composeString(t, "Device", "model", element.getModelElement(), -1); 4697 if (element.hasVersionElement()) 4698 composeString(t, "Device", "version", element.getVersionElement(), -1); 4699 if (element.hasPatient()) 4700 composeReference(t, "Device", "patient", element.getPatient(), -1); 4701 if (element.hasOwner()) 4702 composeReference(t, "Device", "owner", element.getOwner(), -1); 4703 for (int i = 0; i < element.getContact().size(); i++) 4704 composeContactPoint(t, "Device", "contact", element.getContact().get(i), i); 4705 if (element.hasLocation()) 4706 composeReference(t, "Device", "location", element.getLocation(), -1); 4707 if (element.hasUrlElement()) 4708 composeUri(t, "Device", "url", element.getUrlElement(), -1); 4709 for (int i = 0; i < element.getNote().size(); i++) 4710 composeAnnotation(t, "Device", "note", element.getNote().get(i), i); 4711 for (int i = 0; i < element.getSafety().size(); i++) 4712 composeCodeableConcept(t, "Device", "safety", element.getSafety().get(i), i); 4713 } 4714 4715 protected void composeDeviceDeviceUdiComponent(Complex parent, String parentType, String name, Device.DeviceUdiComponent element, int index) { 4716 if (element == null) 4717 return; 4718 Complex t; 4719 if (Utilities.noString(parentType)) 4720 t = parent; 4721 else { 4722 t = parent.predicate("fhir:"+parentType+'.'+name); 4723 } 4724 composeBackboneElement(t, "udi", name, element, index); 4725 if (element.hasDeviceIdentifierElement()) 4726 composeString(t, "Device", "deviceIdentifier", element.getDeviceIdentifierElement(), -1); 4727 if (element.hasNameElement()) 4728 composeString(t, "Device", "name", element.getNameElement(), -1); 4729 if (element.hasJurisdictionElement()) 4730 composeUri(t, "Device", "jurisdiction", element.getJurisdictionElement(), -1); 4731 if (element.hasCarrierHRFElement()) 4732 composeString(t, "Device", "carrierHRF", element.getCarrierHRFElement(), -1); 4733 if (element.hasCarrierAIDCElement()) 4734 composeBase64Binary(t, "Device", "carrierAIDC", element.getCarrierAIDCElement(), -1); 4735 if (element.hasIssuerElement()) 4736 composeUri(t, "Device", "issuer", element.getIssuerElement(), -1); 4737 if (element.hasEntryTypeElement()) 4738 composeEnum(t, "Device", "entryType", element.getEntryTypeElement(), -1); 4739 } 4740 4741 protected void composeDeviceComponent(Complex parent, String parentType, String name, DeviceComponent element, int index) { 4742 if (element == null) 4743 return; 4744 Complex t; 4745 if (Utilities.noString(parentType)) 4746 t = parent; 4747 else { 4748 t = parent.predicate("fhir:"+parentType+'.'+name); 4749 } 4750 composeDomainResource(t, "DeviceComponent", name, element, index); 4751 if (element.hasIdentifier()) 4752 composeIdentifier(t, "DeviceComponent", "identifier", element.getIdentifier(), -1); 4753 if (element.hasType()) 4754 composeCodeableConcept(t, "DeviceComponent", "type", element.getType(), -1); 4755 if (element.hasLastSystemChangeElement()) 4756 composeInstant(t, "DeviceComponent", "lastSystemChange", element.getLastSystemChangeElement(), -1); 4757 if (element.hasSource()) 4758 composeReference(t, "DeviceComponent", "source", element.getSource(), -1); 4759 if (element.hasParent()) 4760 composeReference(t, "DeviceComponent", "parent", element.getParent(), -1); 4761 for (int i = 0; i < element.getOperationalStatus().size(); i++) 4762 composeCodeableConcept(t, "DeviceComponent", "operationalStatus", element.getOperationalStatus().get(i), i); 4763 if (element.hasParameterGroup()) 4764 composeCodeableConcept(t, "DeviceComponent", "parameterGroup", element.getParameterGroup(), -1); 4765 if (element.hasMeasurementPrincipleElement()) 4766 composeEnum(t, "DeviceComponent", "measurementPrinciple", element.getMeasurementPrincipleElement(), -1); 4767 for (int i = 0; i < element.getProductionSpecification().size(); i++) 4768 composeDeviceComponentDeviceComponentProductionSpecificationComponent(t, "DeviceComponent", "productionSpecification", element.getProductionSpecification().get(i), i); 4769 if (element.hasLanguageCode()) 4770 composeCodeableConcept(t, "DeviceComponent", "languageCode", element.getLanguageCode(), -1); 4771 } 4772 4773 protected void composeDeviceComponentDeviceComponentProductionSpecificationComponent(Complex parent, String parentType, String name, DeviceComponent.DeviceComponentProductionSpecificationComponent element, int index) { 4774 if (element == null) 4775 return; 4776 Complex t; 4777 if (Utilities.noString(parentType)) 4778 t = parent; 4779 else { 4780 t = parent.predicate("fhir:"+parentType+'.'+name); 4781 } 4782 composeBackboneElement(t, "productionSpecification", name, element, index); 4783 if (element.hasSpecType()) 4784 composeCodeableConcept(t, "DeviceComponent", "specType", element.getSpecType(), -1); 4785 if (element.hasComponentId()) 4786 composeIdentifier(t, "DeviceComponent", "componentId", element.getComponentId(), -1); 4787 if (element.hasProductionSpecElement()) 4788 composeString(t, "DeviceComponent", "productionSpec", element.getProductionSpecElement(), -1); 4789 } 4790 4791 protected void composeDeviceMetric(Complex parent, String parentType, String name, DeviceMetric element, int index) { 4792 if (element == null) 4793 return; 4794 Complex t; 4795 if (Utilities.noString(parentType)) 4796 t = parent; 4797 else { 4798 t = parent.predicate("fhir:"+parentType+'.'+name); 4799 } 4800 composeDomainResource(t, "DeviceMetric", name, element, index); 4801 if (element.hasIdentifier()) 4802 composeIdentifier(t, "DeviceMetric", "identifier", element.getIdentifier(), -1); 4803 if (element.hasType()) 4804 composeCodeableConcept(t, "DeviceMetric", "type", element.getType(), -1); 4805 if (element.hasUnit()) 4806 composeCodeableConcept(t, "DeviceMetric", "unit", element.getUnit(), -1); 4807 if (element.hasSource()) 4808 composeReference(t, "DeviceMetric", "source", element.getSource(), -1); 4809 if (element.hasParent()) 4810 composeReference(t, "DeviceMetric", "parent", element.getParent(), -1); 4811 if (element.hasOperationalStatusElement()) 4812 composeEnum(t, "DeviceMetric", "operationalStatus", element.getOperationalStatusElement(), -1); 4813 if (element.hasColorElement()) 4814 composeEnum(t, "DeviceMetric", "color", element.getColorElement(), -1); 4815 if (element.hasCategoryElement()) 4816 composeEnum(t, "DeviceMetric", "category", element.getCategoryElement(), -1); 4817 if (element.hasMeasurementPeriod()) 4818 composeTiming(t, "DeviceMetric", "measurementPeriod", element.getMeasurementPeriod(), -1); 4819 for (int i = 0; i < element.getCalibration().size(); i++) 4820 composeDeviceMetricDeviceMetricCalibrationComponent(t, "DeviceMetric", "calibration", element.getCalibration().get(i), i); 4821 } 4822 4823 protected void composeDeviceMetricDeviceMetricCalibrationComponent(Complex parent, String parentType, String name, DeviceMetric.DeviceMetricCalibrationComponent element, int index) { 4824 if (element == null) 4825 return; 4826 Complex t; 4827 if (Utilities.noString(parentType)) 4828 t = parent; 4829 else { 4830 t = parent.predicate("fhir:"+parentType+'.'+name); 4831 } 4832 composeBackboneElement(t, "calibration", name, element, index); 4833 if (element.hasTypeElement()) 4834 composeEnum(t, "DeviceMetric", "type", element.getTypeElement(), -1); 4835 if (element.hasStateElement()) 4836 composeEnum(t, "DeviceMetric", "state", element.getStateElement(), -1); 4837 if (element.hasTimeElement()) 4838 composeInstant(t, "DeviceMetric", "time", element.getTimeElement(), -1); 4839 } 4840 4841 protected void composeDeviceRequest(Complex parent, String parentType, String name, DeviceRequest element, int index) { 4842 if (element == null) 4843 return; 4844 Complex t; 4845 if (Utilities.noString(parentType)) 4846 t = parent; 4847 else { 4848 t = parent.predicate("fhir:"+parentType+'.'+name); 4849 } 4850 composeDomainResource(t, "DeviceRequest", name, element, index); 4851 for (int i = 0; i < element.getIdentifier().size(); i++) 4852 composeIdentifier(t, "DeviceRequest", "identifier", element.getIdentifier().get(i), i); 4853 for (int i = 0; i < element.getDefinition().size(); i++) 4854 composeReference(t, "DeviceRequest", "definition", element.getDefinition().get(i), i); 4855 for (int i = 0; i < element.getBasedOn().size(); i++) 4856 composeReference(t, "DeviceRequest", "basedOn", element.getBasedOn().get(i), i); 4857 for (int i = 0; i < element.getPriorRequest().size(); i++) 4858 composeReference(t, "DeviceRequest", "priorRequest", element.getPriorRequest().get(i), i); 4859 if (element.hasGroupIdentifier()) 4860 composeIdentifier(t, "DeviceRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 4861 if (element.hasStatusElement()) 4862 composeEnum(t, "DeviceRequest", "status", element.getStatusElement(), -1); 4863 if (element.hasIntent()) 4864 composeCodeableConcept(t, "DeviceRequest", "intent", element.getIntent(), -1); 4865 if (element.hasPriorityElement()) 4866 composeEnum(t, "DeviceRequest", "priority", element.getPriorityElement(), -1); 4867 if (element.hasCode()) 4868 composeType(t, "DeviceRequest", "code", element.getCode(), -1); 4869 if (element.hasSubject()) 4870 composeReference(t, "DeviceRequest", "subject", element.getSubject(), -1); 4871 if (element.hasContext()) 4872 composeReference(t, "DeviceRequest", "context", element.getContext(), -1); 4873 if (element.hasOccurrence()) 4874 composeType(t, "DeviceRequest", "occurrence", element.getOccurrence(), -1); 4875 if (element.hasAuthoredOnElement()) 4876 composeDateTime(t, "DeviceRequest", "authoredOn", element.getAuthoredOnElement(), -1); 4877 if (element.hasRequester()) 4878 composeDeviceRequestDeviceRequestRequesterComponent(t, "DeviceRequest", "requester", element.getRequester(), -1); 4879 if (element.hasPerformerType()) 4880 composeCodeableConcept(t, "DeviceRequest", "performerType", element.getPerformerType(), -1); 4881 if (element.hasPerformer()) 4882 composeReference(t, "DeviceRequest", "performer", element.getPerformer(), -1); 4883 for (int i = 0; i < element.getReasonCode().size(); i++) 4884 composeCodeableConcept(t, "DeviceRequest", "reasonCode", element.getReasonCode().get(i), i); 4885 for (int i = 0; i < element.getReasonReference().size(); i++) 4886 composeReference(t, "DeviceRequest", "reasonReference", element.getReasonReference().get(i), i); 4887 for (int i = 0; i < element.getSupportingInfo().size(); i++) 4888 composeReference(t, "DeviceRequest", "supportingInfo", element.getSupportingInfo().get(i), i); 4889 for (int i = 0; i < element.getNote().size(); i++) 4890 composeAnnotation(t, "DeviceRequest", "note", element.getNote().get(i), i); 4891 for (int i = 0; i < element.getRelevantHistory().size(); i++) 4892 composeReference(t, "DeviceRequest", "relevantHistory", element.getRelevantHistory().get(i), i); 4893 } 4894 4895 protected void composeDeviceRequestDeviceRequestRequesterComponent(Complex parent, String parentType, String name, DeviceRequest.DeviceRequestRequesterComponent element, int index) { 4896 if (element == null) 4897 return; 4898 Complex t; 4899 if (Utilities.noString(parentType)) 4900 t = parent; 4901 else { 4902 t = parent.predicate("fhir:"+parentType+'.'+name); 4903 } 4904 composeBackboneElement(t, "requester", name, element, index); 4905 if (element.hasAgent()) 4906 composeReference(t, "DeviceRequest", "agent", element.getAgent(), -1); 4907 if (element.hasOnBehalfOf()) 4908 composeReference(t, "DeviceRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 4909 } 4910 4911 protected void composeDeviceUseStatement(Complex parent, String parentType, String name, DeviceUseStatement element, int index) { 4912 if (element == null) 4913 return; 4914 Complex t; 4915 if (Utilities.noString(parentType)) 4916 t = parent; 4917 else { 4918 t = parent.predicate("fhir:"+parentType+'.'+name); 4919 } 4920 composeDomainResource(t, "DeviceUseStatement", name, element, index); 4921 for (int i = 0; i < element.getIdentifier().size(); i++) 4922 composeIdentifier(t, "DeviceUseStatement", "identifier", element.getIdentifier().get(i), i); 4923 if (element.hasStatusElement()) 4924 composeEnum(t, "DeviceUseStatement", "status", element.getStatusElement(), -1); 4925 if (element.hasSubject()) 4926 composeReference(t, "DeviceUseStatement", "subject", element.getSubject(), -1); 4927 if (element.hasWhenUsed()) 4928 composePeriod(t, "DeviceUseStatement", "whenUsed", element.getWhenUsed(), -1); 4929 if (element.hasTiming()) 4930 composeType(t, "DeviceUseStatement", "timing", element.getTiming(), -1); 4931 if (element.hasRecordedOnElement()) 4932 composeDateTime(t, "DeviceUseStatement", "recordedOn", element.getRecordedOnElement(), -1); 4933 if (element.hasSource()) 4934 composeReference(t, "DeviceUseStatement", "source", element.getSource(), -1); 4935 if (element.hasDevice()) 4936 composeReference(t, "DeviceUseStatement", "device", element.getDevice(), -1); 4937 for (int i = 0; i < element.getIndication().size(); i++) 4938 composeCodeableConcept(t, "DeviceUseStatement", "indication", element.getIndication().get(i), i); 4939 if (element.hasBodySite()) 4940 composeCodeableConcept(t, "DeviceUseStatement", "bodySite", element.getBodySite(), -1); 4941 for (int i = 0; i < element.getNote().size(); i++) 4942 composeAnnotation(t, "DeviceUseStatement", "note", element.getNote().get(i), i); 4943 } 4944 4945 protected void composeDiagnosticReport(Complex parent, String parentType, String name, DiagnosticReport element, int index) { 4946 if (element == null) 4947 return; 4948 Complex t; 4949 if (Utilities.noString(parentType)) 4950 t = parent; 4951 else { 4952 t = parent.predicate("fhir:"+parentType+'.'+name); 4953 } 4954 composeDomainResource(t, "DiagnosticReport", name, element, index); 4955 for (int i = 0; i < element.getIdentifier().size(); i++) 4956 composeIdentifier(t, "DiagnosticReport", "identifier", element.getIdentifier().get(i), i); 4957 for (int i = 0; i < element.getBasedOn().size(); i++) 4958 composeReference(t, "DiagnosticReport", "basedOn", element.getBasedOn().get(i), i); 4959 if (element.hasStatusElement()) 4960 composeEnum(t, "DiagnosticReport", "status", element.getStatusElement(), -1); 4961 if (element.hasCategory()) 4962 composeCodeableConcept(t, "DiagnosticReport", "category", element.getCategory(), -1); 4963 if (element.hasCode()) 4964 composeCodeableConcept(t, "DiagnosticReport", "code", element.getCode(), -1); 4965 if (element.hasSubject()) 4966 composeReference(t, "DiagnosticReport", "subject", element.getSubject(), -1); 4967 if (element.hasContext()) 4968 composeReference(t, "DiagnosticReport", "context", element.getContext(), -1); 4969 if (element.hasEffective()) 4970 composeType(t, "DiagnosticReport", "effective", element.getEffective(), -1); 4971 if (element.hasIssuedElement()) 4972 composeInstant(t, "DiagnosticReport", "issued", element.getIssuedElement(), -1); 4973 for (int i = 0; i < element.getPerformer().size(); i++) 4974 composeDiagnosticReportDiagnosticReportPerformerComponent(t, "DiagnosticReport", "performer", element.getPerformer().get(i), i); 4975 for (int i = 0; i < element.getSpecimen().size(); i++) 4976 composeReference(t, "DiagnosticReport", "specimen", element.getSpecimen().get(i), i); 4977 for (int i = 0; i < element.getResult().size(); i++) 4978 composeReference(t, "DiagnosticReport", "result", element.getResult().get(i), i); 4979 for (int i = 0; i < element.getImagingStudy().size(); i++) 4980 composeReference(t, "DiagnosticReport", "imagingStudy", element.getImagingStudy().get(i), i); 4981 for (int i = 0; i < element.getImage().size(); i++) 4982 composeDiagnosticReportDiagnosticReportImageComponent(t, "DiagnosticReport", "image", element.getImage().get(i), i); 4983 if (element.hasConclusionElement()) 4984 composeString(t, "DiagnosticReport", "conclusion", element.getConclusionElement(), -1); 4985 for (int i = 0; i < element.getCodedDiagnosis().size(); i++) 4986 composeCodeableConcept(t, "DiagnosticReport", "codedDiagnosis", element.getCodedDiagnosis().get(i), i); 4987 for (int i = 0; i < element.getPresentedForm().size(); i++) 4988 composeAttachment(t, "DiagnosticReport", "presentedForm", element.getPresentedForm().get(i), i); 4989 } 4990 4991 protected void composeDiagnosticReportDiagnosticReportPerformerComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportPerformerComponent element, int index) { 4992 if (element == null) 4993 return; 4994 Complex t; 4995 if (Utilities.noString(parentType)) 4996 t = parent; 4997 else { 4998 t = parent.predicate("fhir:"+parentType+'.'+name); 4999 } 5000 composeBackboneElement(t, "performer", name, element, index); 5001 if (element.hasRole()) 5002 composeCodeableConcept(t, "DiagnosticReport", "role", element.getRole(), -1); 5003 if (element.hasActor()) 5004 composeReference(t, "DiagnosticReport", "actor", element.getActor(), -1); 5005 } 5006 5007 protected void composeDiagnosticReportDiagnosticReportImageComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportImageComponent element, int index) { 5008 if (element == null) 5009 return; 5010 Complex t; 5011 if (Utilities.noString(parentType)) 5012 t = parent; 5013 else { 5014 t = parent.predicate("fhir:"+parentType+'.'+name); 5015 } 5016 composeBackboneElement(t, "image", name, element, index); 5017 if (element.hasCommentElement()) 5018 composeString(t, "DiagnosticReport", "comment", element.getCommentElement(), -1); 5019 if (element.hasLink()) 5020 composeReference(t, "DiagnosticReport", "link", element.getLink(), -1); 5021 } 5022 5023 protected void composeDocumentManifest(Complex parent, String parentType, String name, DocumentManifest element, int index) { 5024 if (element == null) 5025 return; 5026 Complex t; 5027 if (Utilities.noString(parentType)) 5028 t = parent; 5029 else { 5030 t = parent.predicate("fhir:"+parentType+'.'+name); 5031 } 5032 composeDomainResource(t, "DocumentManifest", name, element, index); 5033 if (element.hasMasterIdentifier()) 5034 composeIdentifier(t, "DocumentManifest", "masterIdentifier", element.getMasterIdentifier(), -1); 5035 for (int i = 0; i < element.getIdentifier().size(); i++) 5036 composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier().get(i), i); 5037 if (element.hasStatusElement()) 5038 composeEnum(t, "DocumentManifest", "status", element.getStatusElement(), -1); 5039 if (element.hasType()) 5040 composeCodeableConcept(t, "DocumentManifest", "type", element.getType(), -1); 5041 if (element.hasSubject()) 5042 composeReference(t, "DocumentManifest", "subject", element.getSubject(), -1); 5043 if (element.hasCreatedElement()) 5044 composeDateTime(t, "DocumentManifest", "created", element.getCreatedElement(), -1); 5045 for (int i = 0; i < element.getAuthor().size(); i++) 5046 composeReference(t, "DocumentManifest", "author", element.getAuthor().get(i), i); 5047 for (int i = 0; i < element.getRecipient().size(); i++) 5048 composeReference(t, "DocumentManifest", "recipient", element.getRecipient().get(i), i); 5049 if (element.hasSourceElement()) 5050 composeUri(t, "DocumentManifest", "source", element.getSourceElement(), -1); 5051 if (element.hasDescriptionElement()) 5052 composeString(t, "DocumentManifest", "description", element.getDescriptionElement(), -1); 5053 for (int i = 0; i < element.getContent().size(); i++) 5054 composeDocumentManifestDocumentManifestContentComponent(t, "DocumentManifest", "content", element.getContent().get(i), i); 5055 for (int i = 0; i < element.getRelated().size(); i++) 5056 composeDocumentManifestDocumentManifestRelatedComponent(t, "DocumentManifest", "related", element.getRelated().get(i), i); 5057 } 5058 5059 protected void composeDocumentManifestDocumentManifestContentComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestContentComponent element, int index) { 5060 if (element == null) 5061 return; 5062 Complex t; 5063 if (Utilities.noString(parentType)) 5064 t = parent; 5065 else { 5066 t = parent.predicate("fhir:"+parentType+'.'+name); 5067 } 5068 composeBackboneElement(t, "content", name, element, index); 5069 if (element.hasP()) 5070 composeType(t, "DocumentManifest", "p", element.getP(), -1); 5071 } 5072 5073 protected void composeDocumentManifestDocumentManifestRelatedComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestRelatedComponent element, int index) { 5074 if (element == null) 5075 return; 5076 Complex t; 5077 if (Utilities.noString(parentType)) 5078 t = parent; 5079 else { 5080 t = parent.predicate("fhir:"+parentType+'.'+name); 5081 } 5082 composeBackboneElement(t, "related", name, element, index); 5083 if (element.hasIdentifier()) 5084 composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier(), -1); 5085 if (element.hasRef()) 5086 composeReference(t, "DocumentManifest", "ref", element.getRef(), -1); 5087 } 5088 5089 protected void composeDocumentReference(Complex parent, String parentType, String name, DocumentReference element, int index) { 5090 if (element == null) 5091 return; 5092 Complex t; 5093 if (Utilities.noString(parentType)) 5094 t = parent; 5095 else { 5096 t = parent.predicate("fhir:"+parentType+'.'+name); 5097 } 5098 composeDomainResource(t, "DocumentReference", name, element, index); 5099 if (element.hasMasterIdentifier()) 5100 composeIdentifier(t, "DocumentReference", "masterIdentifier", element.getMasterIdentifier(), -1); 5101 for (int i = 0; i < element.getIdentifier().size(); i++) 5102 composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier().get(i), i); 5103 if (element.hasStatusElement()) 5104 composeEnum(t, "DocumentReference", "status", element.getStatusElement(), -1); 5105 if (element.hasDocStatusElement()) 5106 composeEnum(t, "DocumentReference", "docStatus", element.getDocStatusElement(), -1); 5107 if (element.hasType()) 5108 composeCodeableConcept(t, "DocumentReference", "type", element.getType(), -1); 5109 if (element.hasClass_()) 5110 composeCodeableConcept(t, "DocumentReference", "class", element.getClass_(), -1); 5111 if (element.hasSubject()) 5112 composeReference(t, "DocumentReference", "subject", element.getSubject(), -1); 5113 if (element.hasCreatedElement()) 5114 composeDateTime(t, "DocumentReference", "created", element.getCreatedElement(), -1); 5115 if (element.hasIndexedElement()) 5116 composeInstant(t, "DocumentReference", "indexed", element.getIndexedElement(), -1); 5117 for (int i = 0; i < element.getAuthor().size(); i++) 5118 composeReference(t, "DocumentReference", "author", element.getAuthor().get(i), i); 5119 if (element.hasAuthenticator()) 5120 composeReference(t, "DocumentReference", "authenticator", element.getAuthenticator(), -1); 5121 if (element.hasCustodian()) 5122 composeReference(t, "DocumentReference", "custodian", element.getCustodian(), -1); 5123 for (int i = 0; i < element.getRelatesTo().size(); i++) 5124 composeDocumentReferenceDocumentReferenceRelatesToComponent(t, "DocumentReference", "relatesTo", element.getRelatesTo().get(i), i); 5125 if (element.hasDescriptionElement()) 5126 composeString(t, "DocumentReference", "description", element.getDescriptionElement(), -1); 5127 for (int i = 0; i < element.getSecurityLabel().size(); i++) 5128 composeCodeableConcept(t, "DocumentReference", "securityLabel", element.getSecurityLabel().get(i), i); 5129 for (int i = 0; i < element.getContent().size(); i++) 5130 composeDocumentReferenceDocumentReferenceContentComponent(t, "DocumentReference", "content", element.getContent().get(i), i); 5131 if (element.hasContext()) 5132 composeDocumentReferenceDocumentReferenceContextComponent(t, "DocumentReference", "context", element.getContext(), -1); 5133 } 5134 5135 protected void composeDocumentReferenceDocumentReferenceRelatesToComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceRelatesToComponent element, int index) { 5136 if (element == null) 5137 return; 5138 Complex t; 5139 if (Utilities.noString(parentType)) 5140 t = parent; 5141 else { 5142 t = parent.predicate("fhir:"+parentType+'.'+name); 5143 } 5144 composeBackboneElement(t, "relatesTo", name, element, index); 5145 if (element.hasCodeElement()) 5146 composeEnum(t, "DocumentReference", "code", element.getCodeElement(), -1); 5147 if (element.hasTarget()) 5148 composeReference(t, "DocumentReference", "target", element.getTarget(), -1); 5149 } 5150 5151 protected void composeDocumentReferenceDocumentReferenceContentComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContentComponent element, int index) { 5152 if (element == null) 5153 return; 5154 Complex t; 5155 if (Utilities.noString(parentType)) 5156 t = parent; 5157 else { 5158 t = parent.predicate("fhir:"+parentType+'.'+name); 5159 } 5160 composeBackboneElement(t, "content", name, element, index); 5161 if (element.hasAttachment()) 5162 composeAttachment(t, "DocumentReference", "attachment", element.getAttachment(), -1); 5163 if (element.hasFormat()) 5164 composeCoding(t, "DocumentReference", "format", element.getFormat(), -1); 5165 } 5166 5167 protected void composeDocumentReferenceDocumentReferenceContextComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextComponent element, int index) { 5168 if (element == null) 5169 return; 5170 Complex t; 5171 if (Utilities.noString(parentType)) 5172 t = parent; 5173 else { 5174 t = parent.predicate("fhir:"+parentType+'.'+name); 5175 } 5176 composeBackboneElement(t, "context", name, element, index); 5177 if (element.hasEncounter()) 5178 composeReference(t, "DocumentReference", "encounter", element.getEncounter(), -1); 5179 for (int i = 0; i < element.getEvent().size(); i++) 5180 composeCodeableConcept(t, "DocumentReference", "event", element.getEvent().get(i), i); 5181 if (element.hasPeriod()) 5182 composePeriod(t, "DocumentReference", "period", element.getPeriod(), -1); 5183 if (element.hasFacilityType()) 5184 composeCodeableConcept(t, "DocumentReference", "facilityType", element.getFacilityType(), -1); 5185 if (element.hasPracticeSetting()) 5186 composeCodeableConcept(t, "DocumentReference", "practiceSetting", element.getPracticeSetting(), -1); 5187 if (element.hasSourcePatientInfo()) 5188 composeReference(t, "DocumentReference", "sourcePatientInfo", element.getSourcePatientInfo(), -1); 5189 for (int i = 0; i < element.getRelated().size(); i++) 5190 composeDocumentReferenceDocumentReferenceContextRelatedComponent(t, "DocumentReference", "related", element.getRelated().get(i), i); 5191 } 5192 5193 protected void composeDocumentReferenceDocumentReferenceContextRelatedComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextRelatedComponent element, int index) { 5194 if (element == null) 5195 return; 5196 Complex t; 5197 if (Utilities.noString(parentType)) 5198 t = parent; 5199 else { 5200 t = parent.predicate("fhir:"+parentType+'.'+name); 5201 } 5202 composeBackboneElement(t, "related", name, element, index); 5203 if (element.hasIdentifier()) 5204 composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier(), -1); 5205 if (element.hasRef()) 5206 composeReference(t, "DocumentReference", "ref", element.getRef(), -1); 5207 } 5208 5209 protected void composeEligibilityRequest(Complex parent, String parentType, String name, EligibilityRequest element, int index) { 5210 if (element == null) 5211 return; 5212 Complex t; 5213 if (Utilities.noString(parentType)) 5214 t = parent; 5215 else { 5216 t = parent.predicate("fhir:"+parentType+'.'+name); 5217 } 5218 composeDomainResource(t, "EligibilityRequest", name, element, index); 5219 for (int i = 0; i < element.getIdentifier().size(); i++) 5220 composeIdentifier(t, "EligibilityRequest", "identifier", element.getIdentifier().get(i), i); 5221 if (element.hasStatusElement()) 5222 composeEnum(t, "EligibilityRequest", "status", element.getStatusElement(), -1); 5223 if (element.hasPriority()) 5224 composeCodeableConcept(t, "EligibilityRequest", "priority", element.getPriority(), -1); 5225 if (element.hasPatient()) 5226 composeReference(t, "EligibilityRequest", "patient", element.getPatient(), -1); 5227 if (element.hasServiced()) 5228 composeType(t, "EligibilityRequest", "serviced", element.getServiced(), -1); 5229 if (element.hasCreatedElement()) 5230 composeDateTime(t, "EligibilityRequest", "created", element.getCreatedElement(), -1); 5231 if (element.hasEnterer()) 5232 composeReference(t, "EligibilityRequest", "enterer", element.getEnterer(), -1); 5233 if (element.hasProvider()) 5234 composeReference(t, "EligibilityRequest", "provider", element.getProvider(), -1); 5235 if (element.hasOrganization()) 5236 composeReference(t, "EligibilityRequest", "organization", element.getOrganization(), -1); 5237 if (element.hasInsurer()) 5238 composeReference(t, "EligibilityRequest", "insurer", element.getInsurer(), -1); 5239 if (element.hasFacility()) 5240 composeReference(t, "EligibilityRequest", "facility", element.getFacility(), -1); 5241 if (element.hasCoverage()) 5242 composeReference(t, "EligibilityRequest", "coverage", element.getCoverage(), -1); 5243 if (element.hasBusinessArrangementElement()) 5244 composeString(t, "EligibilityRequest", "businessArrangement", element.getBusinessArrangementElement(), -1); 5245 if (element.hasBenefitCategory()) 5246 composeCodeableConcept(t, "EligibilityRequest", "benefitCategory", element.getBenefitCategory(), -1); 5247 if (element.hasBenefitSubCategory()) 5248 composeCodeableConcept(t, "EligibilityRequest", "benefitSubCategory", element.getBenefitSubCategory(), -1); 5249 } 5250 5251 protected void composeEligibilityResponse(Complex parent, String parentType, String name, EligibilityResponse element, int index) { 5252 if (element == null) 5253 return; 5254 Complex t; 5255 if (Utilities.noString(parentType)) 5256 t = parent; 5257 else { 5258 t = parent.predicate("fhir:"+parentType+'.'+name); 5259 } 5260 composeDomainResource(t, "EligibilityResponse", name, element, index); 5261 for (int i = 0; i < element.getIdentifier().size(); i++) 5262 composeIdentifier(t, "EligibilityResponse", "identifier", element.getIdentifier().get(i), i); 5263 if (element.hasStatusElement()) 5264 composeEnum(t, "EligibilityResponse", "status", element.getStatusElement(), -1); 5265 if (element.hasCreatedElement()) 5266 composeDateTime(t, "EligibilityResponse", "created", element.getCreatedElement(), -1); 5267 if (element.hasRequestProvider()) 5268 composeReference(t, "EligibilityResponse", "requestProvider", element.getRequestProvider(), -1); 5269 if (element.hasRequestOrganization()) 5270 composeReference(t, "EligibilityResponse", "requestOrganization", element.getRequestOrganization(), -1); 5271 if (element.hasRequest()) 5272 composeReference(t, "EligibilityResponse", "request", element.getRequest(), -1); 5273 if (element.hasOutcome()) 5274 composeCodeableConcept(t, "EligibilityResponse", "outcome", element.getOutcome(), -1); 5275 if (element.hasDispositionElement()) 5276 composeString(t, "EligibilityResponse", "disposition", element.getDispositionElement(), -1); 5277 if (element.hasInsurer()) 5278 composeReference(t, "EligibilityResponse", "insurer", element.getInsurer(), -1); 5279 if (element.hasInforceElement()) 5280 composeBoolean(t, "EligibilityResponse", "inforce", element.getInforceElement(), -1); 5281 for (int i = 0; i < element.getInsurance().size(); i++) 5282 composeEligibilityResponseInsuranceComponent(t, "EligibilityResponse", "insurance", element.getInsurance().get(i), i); 5283 if (element.hasForm()) 5284 composeCodeableConcept(t, "EligibilityResponse", "form", element.getForm(), -1); 5285 for (int i = 0; i < element.getError().size(); i++) 5286 composeEligibilityResponseErrorsComponent(t, "EligibilityResponse", "error", element.getError().get(i), i); 5287 } 5288 5289 protected void composeEligibilityResponseInsuranceComponent(Complex parent, String parentType, String name, EligibilityResponse.InsuranceComponent element, int index) { 5290 if (element == null) 5291 return; 5292 Complex t; 5293 if (Utilities.noString(parentType)) 5294 t = parent; 5295 else { 5296 t = parent.predicate("fhir:"+parentType+'.'+name); 5297 } 5298 composeBackboneElement(t, "insurance", name, element, index); 5299 if (element.hasCoverage()) 5300 composeReference(t, "EligibilityResponse", "coverage", element.getCoverage(), -1); 5301 if (element.hasContract()) 5302 composeReference(t, "EligibilityResponse", "contract", element.getContract(), -1); 5303 for (int i = 0; i < element.getBenefitBalance().size(); i++) 5304 composeEligibilityResponseBenefitsComponent(t, "EligibilityResponse", "benefitBalance", element.getBenefitBalance().get(i), i); 5305 } 5306 5307 protected void composeEligibilityResponseBenefitsComponent(Complex parent, String parentType, String name, EligibilityResponse.BenefitsComponent element, int index) { 5308 if (element == null) 5309 return; 5310 Complex t; 5311 if (Utilities.noString(parentType)) 5312 t = parent; 5313 else { 5314 t = parent.predicate("fhir:"+parentType+'.'+name); 5315 } 5316 composeBackboneElement(t, "benefitBalance", name, element, index); 5317 if (element.hasCategory()) 5318 composeCodeableConcept(t, "EligibilityResponse", "category", element.getCategory(), -1); 5319 if (element.hasSubCategory()) 5320 composeCodeableConcept(t, "EligibilityResponse", "subCategory", element.getSubCategory(), -1); 5321 if (element.hasExcludedElement()) 5322 composeBoolean(t, "EligibilityResponse", "excluded", element.getExcludedElement(), -1); 5323 if (element.hasNameElement()) 5324 composeString(t, "EligibilityResponse", "name", element.getNameElement(), -1); 5325 if (element.hasDescriptionElement()) 5326 composeString(t, "EligibilityResponse", "description", element.getDescriptionElement(), -1); 5327 if (element.hasNetwork()) 5328 composeCodeableConcept(t, "EligibilityResponse", "network", element.getNetwork(), -1); 5329 if (element.hasUnit()) 5330 composeCodeableConcept(t, "EligibilityResponse", "unit", element.getUnit(), -1); 5331 if (element.hasTerm()) 5332 composeCodeableConcept(t, "EligibilityResponse", "term", element.getTerm(), -1); 5333 for (int i = 0; i < element.getFinancial().size(); i++) 5334 composeEligibilityResponseBenefitComponent(t, "EligibilityResponse", "financial", element.getFinancial().get(i), i); 5335 } 5336 5337 protected void composeEligibilityResponseBenefitComponent(Complex parent, String parentType, String name, EligibilityResponse.BenefitComponent element, int index) { 5338 if (element == null) 5339 return; 5340 Complex t; 5341 if (Utilities.noString(parentType)) 5342 t = parent; 5343 else { 5344 t = parent.predicate("fhir:"+parentType+'.'+name); 5345 } 5346 composeBackboneElement(t, "financial", name, element, index); 5347 if (element.hasType()) 5348 composeCodeableConcept(t, "EligibilityResponse", "type", element.getType(), -1); 5349 if (element.hasAllowed()) 5350 composeType(t, "EligibilityResponse", "allowed", element.getAllowed(), -1); 5351 if (element.hasUsed()) 5352 composeType(t, "EligibilityResponse", "used", element.getUsed(), -1); 5353 } 5354 5355 protected void composeEligibilityResponseErrorsComponent(Complex parent, String parentType, String name, EligibilityResponse.ErrorsComponent element, int index) { 5356 if (element == null) 5357 return; 5358 Complex t; 5359 if (Utilities.noString(parentType)) 5360 t = parent; 5361 else { 5362 t = parent.predicate("fhir:"+parentType+'.'+name); 5363 } 5364 composeBackboneElement(t, "error", name, element, index); 5365 if (element.hasCode()) 5366 composeCodeableConcept(t, "EligibilityResponse", "code", element.getCode(), -1); 5367 } 5368 5369 protected void composeEncounter(Complex parent, String parentType, String name, Encounter element, int index) { 5370 if (element == null) 5371 return; 5372 Complex t; 5373 if (Utilities.noString(parentType)) 5374 t = parent; 5375 else { 5376 t = parent.predicate("fhir:"+parentType+'.'+name); 5377 } 5378 composeDomainResource(t, "Encounter", name, element, index); 5379 for (int i = 0; i < element.getIdentifier().size(); i++) 5380 composeIdentifier(t, "Encounter", "identifier", element.getIdentifier().get(i), i); 5381 if (element.hasStatusElement()) 5382 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 5383 for (int i = 0; i < element.getStatusHistory().size(); i++) 5384 composeEncounterStatusHistoryComponent(t, "Encounter", "statusHistory", element.getStatusHistory().get(i), i); 5385 if (element.hasClass_()) 5386 composeCoding(t, "Encounter", "class", element.getClass_(), -1); 5387 for (int i = 0; i < element.getClassHistory().size(); i++) 5388 composeEncounterClassHistoryComponent(t, "Encounter", "classHistory", element.getClassHistory().get(i), i); 5389 for (int i = 0; i < element.getType().size(); i++) 5390 composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i); 5391 if (element.hasPriority()) 5392 composeCodeableConcept(t, "Encounter", "priority", element.getPriority(), -1); 5393 if (element.hasSubject()) 5394 composeReference(t, "Encounter", "subject", element.getSubject(), -1); 5395 for (int i = 0; i < element.getEpisodeOfCare().size(); i++) 5396 composeReference(t, "Encounter", "episodeOfCare", element.getEpisodeOfCare().get(i), i); 5397 for (int i = 0; i < element.getIncomingReferral().size(); i++) 5398 composeReference(t, "Encounter", "incomingReferral", element.getIncomingReferral().get(i), i); 5399 for (int i = 0; i < element.getParticipant().size(); i++) 5400 composeEncounterEncounterParticipantComponent(t, "Encounter", "participant", element.getParticipant().get(i), i); 5401 if (element.hasAppointment()) 5402 composeReference(t, "Encounter", "appointment", element.getAppointment(), -1); 5403 if (element.hasPeriod()) 5404 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5405 if (element.hasLength()) 5406 composeDuration(t, "Encounter", "length", element.getLength(), -1); 5407 for (int i = 0; i < element.getReason().size(); i++) 5408 composeCodeableConcept(t, "Encounter", "reason", element.getReason().get(i), i); 5409 for (int i = 0; i < element.getDiagnosis().size(); i++) 5410 composeEncounterDiagnosisComponent(t, "Encounter", "diagnosis", element.getDiagnosis().get(i), i); 5411 for (int i = 0; i < element.getAccount().size(); i++) 5412 composeReference(t, "Encounter", "account", element.getAccount().get(i), i); 5413 if (element.hasHospitalization()) 5414 composeEncounterEncounterHospitalizationComponent(t, "Encounter", "hospitalization", element.getHospitalization(), -1); 5415 for (int i = 0; i < element.getLocation().size(); i++) 5416 composeEncounterEncounterLocationComponent(t, "Encounter", "location", element.getLocation().get(i), i); 5417 if (element.hasServiceProvider()) 5418 composeReference(t, "Encounter", "serviceProvider", element.getServiceProvider(), -1); 5419 if (element.hasPartOf()) 5420 composeReference(t, "Encounter", "partOf", element.getPartOf(), -1); 5421 } 5422 5423 protected void composeEncounterStatusHistoryComponent(Complex parent, String parentType, String name, Encounter.StatusHistoryComponent element, int index) { 5424 if (element == null) 5425 return; 5426 Complex t; 5427 if (Utilities.noString(parentType)) 5428 t = parent; 5429 else { 5430 t = parent.predicate("fhir:"+parentType+'.'+name); 5431 } 5432 composeBackboneElement(t, "statusHistory", name, element, index); 5433 if (element.hasStatusElement()) 5434 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 5435 if (element.hasPeriod()) 5436 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5437 } 5438 5439 protected void composeEncounterClassHistoryComponent(Complex parent, String parentType, String name, Encounter.ClassHistoryComponent element, int index) { 5440 if (element == null) 5441 return; 5442 Complex t; 5443 if (Utilities.noString(parentType)) 5444 t = parent; 5445 else { 5446 t = parent.predicate("fhir:"+parentType+'.'+name); 5447 } 5448 composeBackboneElement(t, "classHistory", name, element, index); 5449 if (element.hasClass_()) 5450 composeCoding(t, "Encounter", "class", element.getClass_(), -1); 5451 if (element.hasPeriod()) 5452 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5453 } 5454 5455 protected void composeEncounterEncounterParticipantComponent(Complex parent, String parentType, String name, Encounter.EncounterParticipantComponent element, int index) { 5456 if (element == null) 5457 return; 5458 Complex t; 5459 if (Utilities.noString(parentType)) 5460 t = parent; 5461 else { 5462 t = parent.predicate("fhir:"+parentType+'.'+name); 5463 } 5464 composeBackboneElement(t, "participant", name, element, index); 5465 for (int i = 0; i < element.getType().size(); i++) 5466 composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i); 5467 if (element.hasPeriod()) 5468 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5469 if (element.hasIndividual()) 5470 composeReference(t, "Encounter", "individual", element.getIndividual(), -1); 5471 } 5472 5473 protected void composeEncounterDiagnosisComponent(Complex parent, String parentType, String name, Encounter.DiagnosisComponent element, int index) { 5474 if (element == null) 5475 return; 5476 Complex t; 5477 if (Utilities.noString(parentType)) 5478 t = parent; 5479 else { 5480 t = parent.predicate("fhir:"+parentType+'.'+name); 5481 } 5482 composeBackboneElement(t, "diagnosis", name, element, index); 5483 if (element.hasCondition()) 5484 composeReference(t, "Encounter", "condition", element.getCondition(), -1); 5485 if (element.hasRole()) 5486 composeCodeableConcept(t, "Encounter", "role", element.getRole(), -1); 5487 if (element.hasRankElement()) 5488 composePositiveInt(t, "Encounter", "rank", element.getRankElement(), -1); 5489 } 5490 5491 protected void composeEncounterEncounterHospitalizationComponent(Complex parent, String parentType, String name, Encounter.EncounterHospitalizationComponent element, int index) { 5492 if (element == null) 5493 return; 5494 Complex t; 5495 if (Utilities.noString(parentType)) 5496 t = parent; 5497 else { 5498 t = parent.predicate("fhir:"+parentType+'.'+name); 5499 } 5500 composeBackboneElement(t, "hospitalization", name, element, index); 5501 if (element.hasPreAdmissionIdentifier()) 5502 composeIdentifier(t, "Encounter", "preAdmissionIdentifier", element.getPreAdmissionIdentifier(), -1); 5503 if (element.hasOrigin()) 5504 composeReference(t, "Encounter", "origin", element.getOrigin(), -1); 5505 if (element.hasAdmitSource()) 5506 composeCodeableConcept(t, "Encounter", "admitSource", element.getAdmitSource(), -1); 5507 if (element.hasReAdmission()) 5508 composeCodeableConcept(t, "Encounter", "reAdmission", element.getReAdmission(), -1); 5509 for (int i = 0; i < element.getDietPreference().size(); i++) 5510 composeCodeableConcept(t, "Encounter", "dietPreference", element.getDietPreference().get(i), i); 5511 for (int i = 0; i < element.getSpecialCourtesy().size(); i++) 5512 composeCodeableConcept(t, "Encounter", "specialCourtesy", element.getSpecialCourtesy().get(i), i); 5513 for (int i = 0; i < element.getSpecialArrangement().size(); i++) 5514 composeCodeableConcept(t, "Encounter", "specialArrangement", element.getSpecialArrangement().get(i), i); 5515 if (element.hasDestination()) 5516 composeReference(t, "Encounter", "destination", element.getDestination(), -1); 5517 if (element.hasDischargeDisposition()) 5518 composeCodeableConcept(t, "Encounter", "dischargeDisposition", element.getDischargeDisposition(), -1); 5519 } 5520 5521 protected void composeEncounterEncounterLocationComponent(Complex parent, String parentType, String name, Encounter.EncounterLocationComponent element, int index) { 5522 if (element == null) 5523 return; 5524 Complex t; 5525 if (Utilities.noString(parentType)) 5526 t = parent; 5527 else { 5528 t = parent.predicate("fhir:"+parentType+'.'+name); 5529 } 5530 composeBackboneElement(t, "location", name, element, index); 5531 if (element.hasLocation()) 5532 composeReference(t, "Encounter", "location", element.getLocation(), -1); 5533 if (element.hasStatusElement()) 5534 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 5535 if (element.hasPeriod()) 5536 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5537 } 5538 5539 protected void composeEndpoint(Complex parent, String parentType, String name, Endpoint element, int index) { 5540 if (element == null) 5541 return; 5542 Complex t; 5543 if (Utilities.noString(parentType)) 5544 t = parent; 5545 else { 5546 t = parent.predicate("fhir:"+parentType+'.'+name); 5547 } 5548 composeDomainResource(t, "Endpoint", name, element, index); 5549 for (int i = 0; i < element.getIdentifier().size(); i++) 5550 composeIdentifier(t, "Endpoint", "identifier", element.getIdentifier().get(i), i); 5551 if (element.hasStatusElement()) 5552 composeEnum(t, "Endpoint", "status", element.getStatusElement(), -1); 5553 if (element.hasConnectionType()) 5554 composeCoding(t, "Endpoint", "connectionType", element.getConnectionType(), -1); 5555 if (element.hasNameElement()) 5556 composeString(t, "Endpoint", "name", element.getNameElement(), -1); 5557 if (element.hasManagingOrganization()) 5558 composeReference(t, "Endpoint", "managingOrganization", element.getManagingOrganization(), -1); 5559 for (int i = 0; i < element.getContact().size(); i++) 5560 composeContactPoint(t, "Endpoint", "contact", element.getContact().get(i), i); 5561 if (element.hasPeriod()) 5562 composePeriod(t, "Endpoint", "period", element.getPeriod(), -1); 5563 for (int i = 0; i < element.getPayloadType().size(); i++) 5564 composeCodeableConcept(t, "Endpoint", "payloadType", element.getPayloadType().get(i), i); 5565 for (int i = 0; i < element.getPayloadMimeType().size(); i++) 5566 composeCode(t, "Endpoint", "payloadMimeType", element.getPayloadMimeType().get(i), i); 5567 if (element.hasAddressElement()) 5568 composeUri(t, "Endpoint", "address", element.getAddressElement(), -1); 5569 for (int i = 0; i < element.getHeader().size(); i++) 5570 composeString(t, "Endpoint", "header", element.getHeader().get(i), i); 5571 } 5572 5573 protected void composeEnrollmentRequest(Complex parent, String parentType, String name, EnrollmentRequest element, int index) { 5574 if (element == null) 5575 return; 5576 Complex t; 5577 if (Utilities.noString(parentType)) 5578 t = parent; 5579 else { 5580 t = parent.predicate("fhir:"+parentType+'.'+name); 5581 } 5582 composeDomainResource(t, "EnrollmentRequest", name, element, index); 5583 for (int i = 0; i < element.getIdentifier().size(); i++) 5584 composeIdentifier(t, "EnrollmentRequest", "identifier", element.getIdentifier().get(i), i); 5585 if (element.hasStatusElement()) 5586 composeEnum(t, "EnrollmentRequest", "status", element.getStatusElement(), -1); 5587 if (element.hasCreatedElement()) 5588 composeDateTime(t, "EnrollmentRequest", "created", element.getCreatedElement(), -1); 5589 if (element.hasInsurer()) 5590 composeReference(t, "EnrollmentRequest", "insurer", element.getInsurer(), -1); 5591 if (element.hasProvider()) 5592 composeReference(t, "EnrollmentRequest", "provider", element.getProvider(), -1); 5593 if (element.hasOrganization()) 5594 composeReference(t, "EnrollmentRequest", "organization", element.getOrganization(), -1); 5595 if (element.hasSubject()) 5596 composeReference(t, "EnrollmentRequest", "subject", element.getSubject(), -1); 5597 if (element.hasCoverage()) 5598 composeReference(t, "EnrollmentRequest", "coverage", element.getCoverage(), -1); 5599 } 5600 5601 protected void composeEnrollmentResponse(Complex parent, String parentType, String name, EnrollmentResponse element, int index) { 5602 if (element == null) 5603 return; 5604 Complex t; 5605 if (Utilities.noString(parentType)) 5606 t = parent; 5607 else { 5608 t = parent.predicate("fhir:"+parentType+'.'+name); 5609 } 5610 composeDomainResource(t, "EnrollmentResponse", name, element, index); 5611 for (int i = 0; i < element.getIdentifier().size(); i++) 5612 composeIdentifier(t, "EnrollmentResponse", "identifier", element.getIdentifier().get(i), i); 5613 if (element.hasStatusElement()) 5614 composeEnum(t, "EnrollmentResponse", "status", element.getStatusElement(), -1); 5615 if (element.hasRequest()) 5616 composeReference(t, "EnrollmentResponse", "request", element.getRequest(), -1); 5617 if (element.hasOutcome()) 5618 composeCodeableConcept(t, "EnrollmentResponse", "outcome", element.getOutcome(), -1); 5619 if (element.hasDispositionElement()) 5620 composeString(t, "EnrollmentResponse", "disposition", element.getDispositionElement(), -1); 5621 if (element.hasCreatedElement()) 5622 composeDateTime(t, "EnrollmentResponse", "created", element.getCreatedElement(), -1); 5623 if (element.hasOrganization()) 5624 composeReference(t, "EnrollmentResponse", "organization", element.getOrganization(), -1); 5625 if (element.hasRequestProvider()) 5626 composeReference(t, "EnrollmentResponse", "requestProvider", element.getRequestProvider(), -1); 5627 if (element.hasRequestOrganization()) 5628 composeReference(t, "EnrollmentResponse", "requestOrganization", element.getRequestOrganization(), -1); 5629 } 5630 5631 protected void composeEpisodeOfCare(Complex parent, String parentType, String name, EpisodeOfCare element, int index) { 5632 if (element == null) 5633 return; 5634 Complex t; 5635 if (Utilities.noString(parentType)) 5636 t = parent; 5637 else { 5638 t = parent.predicate("fhir:"+parentType+'.'+name); 5639 } 5640 composeDomainResource(t, "EpisodeOfCare", name, element, index); 5641 for (int i = 0; i < element.getIdentifier().size(); i++) 5642 composeIdentifier(t, "EpisodeOfCare", "identifier", element.getIdentifier().get(i), i); 5643 if (element.hasStatusElement()) 5644 composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1); 5645 for (int i = 0; i < element.getStatusHistory().size(); i++) 5646 composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(t, "EpisodeOfCare", "statusHistory", element.getStatusHistory().get(i), i); 5647 for (int i = 0; i < element.getType().size(); i++) 5648 composeCodeableConcept(t, "EpisodeOfCare", "type", element.getType().get(i), i); 5649 for (int i = 0; i < element.getDiagnosis().size(); i++) 5650 composeEpisodeOfCareDiagnosisComponent(t, "EpisodeOfCare", "diagnosis", element.getDiagnosis().get(i), i); 5651 if (element.hasPatient()) 5652 composeReference(t, "EpisodeOfCare", "patient", element.getPatient(), -1); 5653 if (element.hasManagingOrganization()) 5654 composeReference(t, "EpisodeOfCare", "managingOrganization", element.getManagingOrganization(), -1); 5655 if (element.hasPeriod()) 5656 composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1); 5657 for (int i = 0; i < element.getReferralRequest().size(); i++) 5658 composeReference(t, "EpisodeOfCare", "referralRequest", element.getReferralRequest().get(i), i); 5659 if (element.hasCareManager()) 5660 composeReference(t, "EpisodeOfCare", "careManager", element.getCareManager(), -1); 5661 for (int i = 0; i < element.getTeam().size(); i++) 5662 composeReference(t, "EpisodeOfCare", "team", element.getTeam().get(i), i); 5663 for (int i = 0; i < element.getAccount().size(); i++) 5664 composeReference(t, "EpisodeOfCare", "account", element.getAccount().get(i), i); 5665 } 5666 5667 protected void composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(Complex parent, String parentType, String name, EpisodeOfCare.EpisodeOfCareStatusHistoryComponent element, int index) { 5668 if (element == null) 5669 return; 5670 Complex t; 5671 if (Utilities.noString(parentType)) 5672 t = parent; 5673 else { 5674 t = parent.predicate("fhir:"+parentType+'.'+name); 5675 } 5676 composeBackboneElement(t, "statusHistory", name, element, index); 5677 if (element.hasStatusElement()) 5678 composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1); 5679 if (element.hasPeriod()) 5680 composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1); 5681 } 5682 5683 protected void composeEpisodeOfCareDiagnosisComponent(Complex parent, String parentType, String name, EpisodeOfCare.DiagnosisComponent element, int index) { 5684 if (element == null) 5685 return; 5686 Complex t; 5687 if (Utilities.noString(parentType)) 5688 t = parent; 5689 else { 5690 t = parent.predicate("fhir:"+parentType+'.'+name); 5691 } 5692 composeBackboneElement(t, "diagnosis", name, element, index); 5693 if (element.hasCondition()) 5694 composeReference(t, "EpisodeOfCare", "condition", element.getCondition(), -1); 5695 if (element.hasRole()) 5696 composeCodeableConcept(t, "EpisodeOfCare", "role", element.getRole(), -1); 5697 if (element.hasRankElement()) 5698 composePositiveInt(t, "EpisodeOfCare", "rank", element.getRankElement(), -1); 5699 } 5700 5701 protected void composeExpansionProfile(Complex parent, String parentType, String name, ExpansionProfile element, int index) { 5702 if (element == null) 5703 return; 5704 Complex t; 5705 if (Utilities.noString(parentType)) 5706 t = parent; 5707 else { 5708 t = parent.predicate("fhir:"+parentType+'.'+name); 5709 } 5710 composeDomainResource(t, "ExpansionProfile", name, element, index); 5711 if (element.hasUrlElement()) 5712 composeUri(t, "ExpansionProfile", "url", element.getUrlElement(), -1); 5713 if (element.hasIdentifier()) 5714 composeIdentifier(t, "ExpansionProfile", "identifier", element.getIdentifier(), -1); 5715 if (element.hasVersionElement()) 5716 composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1); 5717 if (element.hasNameElement()) 5718 composeString(t, "ExpansionProfile", "name", element.getNameElement(), -1); 5719 if (element.hasStatusElement()) 5720 composeEnum(t, "ExpansionProfile", "status", element.getStatusElement(), -1); 5721 if (element.hasExperimentalElement()) 5722 composeBoolean(t, "ExpansionProfile", "experimental", element.getExperimentalElement(), -1); 5723 if (element.hasDateElement()) 5724 composeDateTime(t, "ExpansionProfile", "date", element.getDateElement(), -1); 5725 if (element.hasPublisherElement()) 5726 composeString(t, "ExpansionProfile", "publisher", element.getPublisherElement(), -1); 5727 for (int i = 0; i < element.getContact().size(); i++) 5728 composeContactDetail(t, "ExpansionProfile", "contact", element.getContact().get(i), i); 5729 if (element.hasDescriptionElement()) 5730 composeMarkdown(t, "ExpansionProfile", "description", element.getDescriptionElement(), -1); 5731 for (int i = 0; i < element.getUseContext().size(); i++) 5732 composeUsageContext(t, "ExpansionProfile", "useContext", element.getUseContext().get(i), i); 5733 for (int i = 0; i < element.getJurisdiction().size(); i++) 5734 composeCodeableConcept(t, "ExpansionProfile", "jurisdiction", element.getJurisdiction().get(i), i); 5735 for (int i = 0; i < element.getFixedVersion().size(); i++) 5736 composeExpansionProfileExpansionProfileFixedVersionComponent(t, "ExpansionProfile", "fixedVersion", element.getFixedVersion().get(i), i); 5737 if (element.hasExcludedSystem()) 5738 composeExpansionProfileExpansionProfileExcludedSystemComponent(t, "ExpansionProfile", "excludedSystem", element.getExcludedSystem(), -1); 5739 if (element.hasIncludeDesignationsElement()) 5740 composeBoolean(t, "ExpansionProfile", "includeDesignations", element.getIncludeDesignationsElement(), -1); 5741 if (element.hasDesignation()) 5742 composeExpansionProfileExpansionProfileDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation(), -1); 5743 if (element.hasIncludeDefinitionElement()) 5744 composeBoolean(t, "ExpansionProfile", "includeDefinition", element.getIncludeDefinitionElement(), -1); 5745 if (element.hasActiveOnlyElement()) 5746 composeBoolean(t, "ExpansionProfile", "activeOnly", element.getActiveOnlyElement(), -1); 5747 if (element.hasExcludeNestedElement()) 5748 composeBoolean(t, "ExpansionProfile", "excludeNested", element.getExcludeNestedElement(), -1); 5749 if (element.hasExcludeNotForUIElement()) 5750 composeBoolean(t, "ExpansionProfile", "excludeNotForUI", element.getExcludeNotForUIElement(), -1); 5751 if (element.hasExcludePostCoordinatedElement()) 5752 composeBoolean(t, "ExpansionProfile", "excludePostCoordinated", element.getExcludePostCoordinatedElement(), -1); 5753 if (element.hasDisplayLanguageElement()) 5754 composeCode(t, "ExpansionProfile", "displayLanguage", element.getDisplayLanguageElement(), -1); 5755 if (element.hasLimitedExpansionElement()) 5756 composeBoolean(t, "ExpansionProfile", "limitedExpansion", element.getLimitedExpansionElement(), -1); 5757 } 5758 5759 protected void composeExpansionProfileExpansionProfileFixedVersionComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileFixedVersionComponent element, int index) { 5760 if (element == null) 5761 return; 5762 Complex t; 5763 if (Utilities.noString(parentType)) 5764 t = parent; 5765 else { 5766 t = parent.predicate("fhir:"+parentType+'.'+name); 5767 } 5768 composeBackboneElement(t, "fixedVersion", name, element, index); 5769 if (element.hasSystemElement()) 5770 composeUri(t, "ExpansionProfile", "system", element.getSystemElement(), -1); 5771 if (element.hasVersionElement()) 5772 composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1); 5773 if (element.hasModeElement()) 5774 composeEnum(t, "ExpansionProfile", "mode", element.getModeElement(), -1); 5775 } 5776 5777 protected void composeExpansionProfileExpansionProfileExcludedSystemComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileExcludedSystemComponent element, int index) { 5778 if (element == null) 5779 return; 5780 Complex t; 5781 if (Utilities.noString(parentType)) 5782 t = parent; 5783 else { 5784 t = parent.predicate("fhir:"+parentType+'.'+name); 5785 } 5786 composeBackboneElement(t, "excludedSystem", name, element, index); 5787 if (element.hasSystemElement()) 5788 composeUri(t, "ExpansionProfile", "system", element.getSystemElement(), -1); 5789 if (element.hasVersionElement()) 5790 composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1); 5791 } 5792 5793 protected void composeExpansionProfileExpansionProfileDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileDesignationComponent element, int index) { 5794 if (element == null) 5795 return; 5796 Complex t; 5797 if (Utilities.noString(parentType)) 5798 t = parent; 5799 else { 5800 t = parent.predicate("fhir:"+parentType+'.'+name); 5801 } 5802 composeBackboneElement(t, "designation", name, element, index); 5803 if (element.hasInclude()) 5804 composeExpansionProfileDesignationIncludeComponent(t, "ExpansionProfile", "include", element.getInclude(), -1); 5805 if (element.hasExclude()) 5806 composeExpansionProfileDesignationExcludeComponent(t, "ExpansionProfile", "exclude", element.getExclude(), -1); 5807 } 5808 5809 protected void composeExpansionProfileDesignationIncludeComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationIncludeComponent element, int index) { 5810 if (element == null) 5811 return; 5812 Complex t; 5813 if (Utilities.noString(parentType)) 5814 t = parent; 5815 else { 5816 t = parent.predicate("fhir:"+parentType+'.'+name); 5817 } 5818 composeBackboneElement(t, "include", name, element, index); 5819 for (int i = 0; i < element.getDesignation().size(); i++) 5820 composeExpansionProfileDesignationIncludeDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation().get(i), i); 5821 } 5822 5823 protected void composeExpansionProfileDesignationIncludeDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationIncludeDesignationComponent element, int index) { 5824 if (element == null) 5825 return; 5826 Complex t; 5827 if (Utilities.noString(parentType)) 5828 t = parent; 5829 else { 5830 t = parent.predicate("fhir:"+parentType+'.'+name); 5831 } 5832 composeBackboneElement(t, "designation", name, element, index); 5833 if (element.hasLanguageElement()) 5834 composeCode(t, "ExpansionProfile", "language", element.getLanguageElement(), -1); 5835 if (element.hasUse()) 5836 composeCoding(t, "ExpansionProfile", "use", element.getUse(), -1); 5837 } 5838 5839 protected void composeExpansionProfileDesignationExcludeComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationExcludeComponent element, int index) { 5840 if (element == null) 5841 return; 5842 Complex t; 5843 if (Utilities.noString(parentType)) 5844 t = parent; 5845 else { 5846 t = parent.predicate("fhir:"+parentType+'.'+name); 5847 } 5848 composeBackboneElement(t, "exclude", name, element, index); 5849 for (int i = 0; i < element.getDesignation().size(); i++) 5850 composeExpansionProfileDesignationExcludeDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation().get(i), i); 5851 } 5852 5853 protected void composeExpansionProfileDesignationExcludeDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationExcludeDesignationComponent element, int index) { 5854 if (element == null) 5855 return; 5856 Complex t; 5857 if (Utilities.noString(parentType)) 5858 t = parent; 5859 else { 5860 t = parent.predicate("fhir:"+parentType+'.'+name); 5861 } 5862 composeBackboneElement(t, "designation", name, element, index); 5863 if (element.hasLanguageElement()) 5864 composeCode(t, "ExpansionProfile", "language", element.getLanguageElement(), -1); 5865 if (element.hasUse()) 5866 composeCoding(t, "ExpansionProfile", "use", element.getUse(), -1); 5867 } 5868 5869 protected void composeExplanationOfBenefit(Complex parent, String parentType, String name, ExplanationOfBenefit element, int index) { 5870 if (element == null) 5871 return; 5872 Complex t; 5873 if (Utilities.noString(parentType)) 5874 t = parent; 5875 else { 5876 t = parent.predicate("fhir:"+parentType+'.'+name); 5877 } 5878 composeDomainResource(t, "ExplanationOfBenefit", name, element, index); 5879 for (int i = 0; i < element.getIdentifier().size(); i++) 5880 composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier().get(i), i); 5881 if (element.hasStatusElement()) 5882 composeEnum(t, "ExplanationOfBenefit", "status", element.getStatusElement(), -1); 5883 if (element.hasType()) 5884 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 5885 for (int i = 0; i < element.getSubType().size(); i++) 5886 composeCodeableConcept(t, "ExplanationOfBenefit", "subType", element.getSubType().get(i), i); 5887 if (element.hasPatient()) 5888 composeReference(t, "ExplanationOfBenefit", "patient", element.getPatient(), -1); 5889 if (element.hasBillablePeriod()) 5890 composePeriod(t, "ExplanationOfBenefit", "billablePeriod", element.getBillablePeriod(), -1); 5891 if (element.hasCreatedElement()) 5892 composeDateTime(t, "ExplanationOfBenefit", "created", element.getCreatedElement(), -1); 5893 if (element.hasEnterer()) 5894 composeReference(t, "ExplanationOfBenefit", "enterer", element.getEnterer(), -1); 5895 if (element.hasInsurer()) 5896 composeReference(t, "ExplanationOfBenefit", "insurer", element.getInsurer(), -1); 5897 if (element.hasProvider()) 5898 composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1); 5899 if (element.hasOrganization()) 5900 composeReference(t, "ExplanationOfBenefit", "organization", element.getOrganization(), -1); 5901 if (element.hasReferral()) 5902 composeReference(t, "ExplanationOfBenefit", "referral", element.getReferral(), -1); 5903 if (element.hasFacility()) 5904 composeReference(t, "ExplanationOfBenefit", "facility", element.getFacility(), -1); 5905 if (element.hasClaim()) 5906 composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1); 5907 if (element.hasClaimResponse()) 5908 composeReference(t, "ExplanationOfBenefit", "claimResponse", element.getClaimResponse(), -1); 5909 if (element.hasOutcome()) 5910 composeCodeableConcept(t, "ExplanationOfBenefit", "outcome", element.getOutcome(), -1); 5911 if (element.hasDispositionElement()) 5912 composeString(t, "ExplanationOfBenefit", "disposition", element.getDispositionElement(), -1); 5913 for (int i = 0; i < element.getRelated().size(); i++) 5914 composeExplanationOfBenefitRelatedClaimComponent(t, "ExplanationOfBenefit", "related", element.getRelated().get(i), i); 5915 if (element.hasPrescription()) 5916 composeReference(t, "ExplanationOfBenefit", "prescription", element.getPrescription(), -1); 5917 if (element.hasOriginalPrescription()) 5918 composeReference(t, "ExplanationOfBenefit", "originalPrescription", element.getOriginalPrescription(), -1); 5919 if (element.hasPayee()) 5920 composeExplanationOfBenefitPayeeComponent(t, "ExplanationOfBenefit", "payee", element.getPayee(), -1); 5921 for (int i = 0; i < element.getInformation().size(); i++) 5922 composeExplanationOfBenefitSupportingInformationComponent(t, "ExplanationOfBenefit", "information", element.getInformation().get(i), i); 5923 for (int i = 0; i < element.getCareTeam().size(); i++) 5924 composeExplanationOfBenefitCareTeamComponent(t, "ExplanationOfBenefit", "careTeam", element.getCareTeam().get(i), i); 5925 for (int i = 0; i < element.getDiagnosis().size(); i++) 5926 composeExplanationOfBenefitDiagnosisComponent(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis().get(i), i); 5927 for (int i = 0; i < element.getProcedure().size(); i++) 5928 composeExplanationOfBenefitProcedureComponent(t, "ExplanationOfBenefit", "procedure", element.getProcedure().get(i), i); 5929 if (element.hasPrecedenceElement()) 5930 composePositiveInt(t, "ExplanationOfBenefit", "precedence", element.getPrecedenceElement(), -1); 5931 if (element.hasInsurance()) 5932 composeExplanationOfBenefitInsuranceComponent(t, "ExplanationOfBenefit", "insurance", element.getInsurance(), -1); 5933 if (element.hasAccident()) 5934 composeExplanationOfBenefitAccidentComponent(t, "ExplanationOfBenefit", "accident", element.getAccident(), -1); 5935 if (element.hasEmploymentImpacted()) 5936 composePeriod(t, "ExplanationOfBenefit", "employmentImpacted", element.getEmploymentImpacted(), -1); 5937 if (element.hasHospitalization()) 5938 composePeriod(t, "ExplanationOfBenefit", "hospitalization", element.getHospitalization(), -1); 5939 for (int i = 0; i < element.getItem().size(); i++) 5940 composeExplanationOfBenefitItemComponent(t, "ExplanationOfBenefit", "item", element.getItem().get(i), i); 5941 for (int i = 0; i < element.getAddItem().size(); i++) 5942 composeExplanationOfBenefitAddedItemComponent(t, "ExplanationOfBenefit", "addItem", element.getAddItem().get(i), i); 5943 if (element.hasTotalCost()) 5944 composeMoney(t, "ExplanationOfBenefit", "totalCost", element.getTotalCost(), -1); 5945 if (element.hasUnallocDeductable()) 5946 composeMoney(t, "ExplanationOfBenefit", "unallocDeductable", element.getUnallocDeductable(), -1); 5947 if (element.hasTotalBenefit()) 5948 composeMoney(t, "ExplanationOfBenefit", "totalBenefit", element.getTotalBenefit(), -1); 5949 if (element.hasPayment()) 5950 composeExplanationOfBenefitPaymentComponent(t, "ExplanationOfBenefit", "payment", element.getPayment(), -1); 5951 if (element.hasForm()) 5952 composeCodeableConcept(t, "ExplanationOfBenefit", "form", element.getForm(), -1); 5953 for (int i = 0; i < element.getProcessNote().size(); i++) 5954 composeExplanationOfBenefitNoteComponent(t, "ExplanationOfBenefit", "processNote", element.getProcessNote().get(i), i); 5955 for (int i = 0; i < element.getBenefitBalance().size(); i++) 5956 composeExplanationOfBenefitBenefitBalanceComponent(t, "ExplanationOfBenefit", "benefitBalance", element.getBenefitBalance().get(i), i); 5957 } 5958 5959 protected void composeExplanationOfBenefitRelatedClaimComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.RelatedClaimComponent element, int index) { 5960 if (element == null) 5961 return; 5962 Complex t; 5963 if (Utilities.noString(parentType)) 5964 t = parent; 5965 else { 5966 t = parent.predicate("fhir:"+parentType+'.'+name); 5967 } 5968 composeBackboneElement(t, "related", name, element, index); 5969 if (element.hasClaim()) 5970 composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1); 5971 if (element.hasRelationship()) 5972 composeCodeableConcept(t, "ExplanationOfBenefit", "relationship", element.getRelationship(), -1); 5973 if (element.hasReference()) 5974 composeIdentifier(t, "ExplanationOfBenefit", "reference", element.getReference(), -1); 5975 } 5976 5977 protected void composeExplanationOfBenefitPayeeComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PayeeComponent element, int index) { 5978 if (element == null) 5979 return; 5980 Complex t; 5981 if (Utilities.noString(parentType)) 5982 t = parent; 5983 else { 5984 t = parent.predicate("fhir:"+parentType+'.'+name); 5985 } 5986 composeBackboneElement(t, "payee", name, element, index); 5987 if (element.hasType()) 5988 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 5989 if (element.hasResourceType()) 5990 composeCodeableConcept(t, "ExplanationOfBenefit", "resourceType", element.getResourceType(), -1); 5991 if (element.hasParty()) 5992 composeReference(t, "ExplanationOfBenefit", "party", element.getParty(), -1); 5993 } 5994 5995 protected void composeExplanationOfBenefitSupportingInformationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SupportingInformationComponent element, int index) { 5996 if (element == null) 5997 return; 5998 Complex t; 5999 if (Utilities.noString(parentType)) 6000 t = parent; 6001 else { 6002 t = parent.predicate("fhir:"+parentType+'.'+name); 6003 } 6004 composeBackboneElement(t, "information", name, element, index); 6005 if (element.hasSequenceElement()) 6006 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6007 if (element.hasCategory()) 6008 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6009 if (element.hasCode()) 6010 composeCodeableConcept(t, "ExplanationOfBenefit", "code", element.getCode(), -1); 6011 if (element.hasTiming()) 6012 composeType(t, "ExplanationOfBenefit", "timing", element.getTiming(), -1); 6013 if (element.hasValue()) 6014 composeType(t, "ExplanationOfBenefit", "value", element.getValue(), -1); 6015 if (element.hasReason()) 6016 composeCoding(t, "ExplanationOfBenefit", "reason", element.getReason(), -1); 6017 } 6018 6019 protected void composeExplanationOfBenefitCareTeamComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.CareTeamComponent element, int index) { 6020 if (element == null) 6021 return; 6022 Complex t; 6023 if (Utilities.noString(parentType)) 6024 t = parent; 6025 else { 6026 t = parent.predicate("fhir:"+parentType+'.'+name); 6027 } 6028 composeBackboneElement(t, "careTeam", name, element, index); 6029 if (element.hasSequenceElement()) 6030 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6031 if (element.hasProvider()) 6032 composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1); 6033 if (element.hasResponsibleElement()) 6034 composeBoolean(t, "ExplanationOfBenefit", "responsible", element.getResponsibleElement(), -1); 6035 if (element.hasRole()) 6036 composeCodeableConcept(t, "ExplanationOfBenefit", "role", element.getRole(), -1); 6037 if (element.hasQualification()) 6038 composeCodeableConcept(t, "ExplanationOfBenefit", "qualification", element.getQualification(), -1); 6039 } 6040 6041 protected void composeExplanationOfBenefitDiagnosisComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DiagnosisComponent element, int index) { 6042 if (element == null) 6043 return; 6044 Complex t; 6045 if (Utilities.noString(parentType)) 6046 t = parent; 6047 else { 6048 t = parent.predicate("fhir:"+parentType+'.'+name); 6049 } 6050 composeBackboneElement(t, "diagnosis", name, element, index); 6051 if (element.hasSequenceElement()) 6052 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6053 if (element.hasDiagnosis()) 6054 composeType(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis(), -1); 6055 for (int i = 0; i < element.getType().size(); i++) 6056 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType().get(i), i); 6057 if (element.hasPackageCode()) 6058 composeCodeableConcept(t, "ExplanationOfBenefit", "packageCode", element.getPackageCode(), -1); 6059 } 6060 6061 protected void composeExplanationOfBenefitProcedureComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ProcedureComponent element, int index) { 6062 if (element == null) 6063 return; 6064 Complex t; 6065 if (Utilities.noString(parentType)) 6066 t = parent; 6067 else { 6068 t = parent.predicate("fhir:"+parentType+'.'+name); 6069 } 6070 composeBackboneElement(t, "procedure", name, element, index); 6071 if (element.hasSequenceElement()) 6072 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6073 if (element.hasDateElement()) 6074 composeDateTime(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1); 6075 if (element.hasProcedure()) 6076 composeType(t, "ExplanationOfBenefit", "procedure", element.getProcedure(), -1); 6077 } 6078 6079 protected void composeExplanationOfBenefitInsuranceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.InsuranceComponent element, int index) { 6080 if (element == null) 6081 return; 6082 Complex t; 6083 if (Utilities.noString(parentType)) 6084 t = parent; 6085 else { 6086 t = parent.predicate("fhir:"+parentType+'.'+name); 6087 } 6088 composeBackboneElement(t, "insurance", name, element, index); 6089 if (element.hasCoverage()) 6090 composeReference(t, "ExplanationOfBenefit", "coverage", element.getCoverage(), -1); 6091 for (int i = 0; i < element.getPreAuthRef().size(); i++) 6092 composeString(t, "ExplanationOfBenefit", "preAuthRef", element.getPreAuthRef().get(i), i); 6093 } 6094 6095 protected void composeExplanationOfBenefitAccidentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AccidentComponent element, int index) { 6096 if (element == null) 6097 return; 6098 Complex t; 6099 if (Utilities.noString(parentType)) 6100 t = parent; 6101 else { 6102 t = parent.predicate("fhir:"+parentType+'.'+name); 6103 } 6104 composeBackboneElement(t, "accident", name, element, index); 6105 if (element.hasDateElement()) 6106 composeDate(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1); 6107 if (element.hasType()) 6108 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6109 if (element.hasLocation()) 6110 composeType(t, "ExplanationOfBenefit", "location", element.getLocation(), -1); 6111 } 6112 6113 protected void composeExplanationOfBenefitItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ItemComponent element, int index) { 6114 if (element == null) 6115 return; 6116 Complex t; 6117 if (Utilities.noString(parentType)) 6118 t = parent; 6119 else { 6120 t = parent.predicate("fhir:"+parentType+'.'+name); 6121 } 6122 composeBackboneElement(t, "item", name, element, index); 6123 if (element.hasSequenceElement()) 6124 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6125 for (int i = 0; i < element.getCareTeamLinkId().size(); i++) 6126 composePositiveInt(t, "ExplanationOfBenefit", "careTeamLinkId", element.getCareTeamLinkId().get(i), i); 6127 for (int i = 0; i < element.getDiagnosisLinkId().size(); i++) 6128 composePositiveInt(t, "ExplanationOfBenefit", "diagnosisLinkId", element.getDiagnosisLinkId().get(i), i); 6129 for (int i = 0; i < element.getProcedureLinkId().size(); i++) 6130 composePositiveInt(t, "ExplanationOfBenefit", "procedureLinkId", element.getProcedureLinkId().get(i), i); 6131 for (int i = 0; i < element.getInformationLinkId().size(); i++) 6132 composePositiveInt(t, "ExplanationOfBenefit", "informationLinkId", element.getInformationLinkId().get(i), i); 6133 if (element.hasRevenue()) 6134 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6135 if (element.hasCategory()) 6136 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6137 if (element.hasService()) 6138 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6139 for (int i = 0; i < element.getModifier().size(); i++) 6140 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6141 for (int i = 0; i < element.getProgramCode().size(); i++) 6142 composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 6143 if (element.hasServiced()) 6144 composeType(t, "ExplanationOfBenefit", "serviced", element.getServiced(), -1); 6145 if (element.hasLocation()) 6146 composeType(t, "ExplanationOfBenefit", "location", element.getLocation(), -1); 6147 if (element.hasQuantity()) 6148 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 6149 if (element.hasUnitPrice()) 6150 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 6151 if (element.hasFactorElement()) 6152 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 6153 if (element.hasNet()) 6154 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 6155 for (int i = 0; i < element.getUdi().size(); i++) 6156 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 6157 if (element.hasBodySite()) 6158 composeCodeableConcept(t, "ExplanationOfBenefit", "bodySite", element.getBodySite(), -1); 6159 for (int i = 0; i < element.getSubSite().size(); i++) 6160 composeCodeableConcept(t, "ExplanationOfBenefit", "subSite", element.getSubSite().get(i), i); 6161 for (int i = 0; i < element.getEncounter().size(); i++) 6162 composeReference(t, "ExplanationOfBenefit", "encounter", element.getEncounter().get(i), i); 6163 for (int i = 0; i < element.getNoteNumber().size(); i++) 6164 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6165 for (int i = 0; i < element.getAdjudication().size(); i++) 6166 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6167 for (int i = 0; i < element.getDetail().size(); i++) 6168 composeExplanationOfBenefitDetailComponent(t, "ExplanationOfBenefit", "detail", element.getDetail().get(i), i); 6169 } 6170 6171 protected void composeExplanationOfBenefitAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AdjudicationComponent element, int index) { 6172 if (element == null) 6173 return; 6174 Complex t; 6175 if (Utilities.noString(parentType)) 6176 t = parent; 6177 else { 6178 t = parent.predicate("fhir:"+parentType+'.'+name); 6179 } 6180 composeBackboneElement(t, "adjudication", name, element, index); 6181 if (element.hasCategory()) 6182 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6183 if (element.hasReason()) 6184 composeCodeableConcept(t, "ExplanationOfBenefit", "reason", element.getReason(), -1); 6185 if (element.hasAmount()) 6186 composeMoney(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1); 6187 if (element.hasValueElement()) 6188 composeDecimal(t, "ExplanationOfBenefit", "value", element.getValueElement(), -1); 6189 } 6190 6191 protected void composeExplanationOfBenefitDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DetailComponent element, int index) { 6192 if (element == null) 6193 return; 6194 Complex t; 6195 if (Utilities.noString(parentType)) 6196 t = parent; 6197 else { 6198 t = parent.predicate("fhir:"+parentType+'.'+name); 6199 } 6200 composeBackboneElement(t, "detail", name, element, index); 6201 if (element.hasSequenceElement()) 6202 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6203 if (element.hasType()) 6204 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6205 if (element.hasRevenue()) 6206 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6207 if (element.hasCategory()) 6208 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6209 if (element.hasService()) 6210 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6211 for (int i = 0; i < element.getModifier().size(); i++) 6212 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6213 for (int i = 0; i < element.getProgramCode().size(); i++) 6214 composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 6215 if (element.hasQuantity()) 6216 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 6217 if (element.hasUnitPrice()) 6218 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 6219 if (element.hasFactorElement()) 6220 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 6221 if (element.hasNet()) 6222 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 6223 for (int i = 0; i < element.getUdi().size(); i++) 6224 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 6225 for (int i = 0; i < element.getNoteNumber().size(); i++) 6226 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6227 for (int i = 0; i < element.getAdjudication().size(); i++) 6228 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6229 for (int i = 0; i < element.getSubDetail().size(); i++) 6230 composeExplanationOfBenefitSubDetailComponent(t, "ExplanationOfBenefit", "subDetail", element.getSubDetail().get(i), i); 6231 } 6232 6233 protected void composeExplanationOfBenefitSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SubDetailComponent element, int index) { 6234 if (element == null) 6235 return; 6236 Complex t; 6237 if (Utilities.noString(parentType)) 6238 t = parent; 6239 else { 6240 t = parent.predicate("fhir:"+parentType+'.'+name); 6241 } 6242 composeBackboneElement(t, "subDetail", name, element, index); 6243 if (element.hasSequenceElement()) 6244 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6245 if (element.hasType()) 6246 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6247 if (element.hasRevenue()) 6248 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6249 if (element.hasCategory()) 6250 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6251 if (element.hasService()) 6252 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6253 for (int i = 0; i < element.getModifier().size(); i++) 6254 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6255 for (int i = 0; i < element.getProgramCode().size(); i++) 6256 composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 6257 if (element.hasQuantity()) 6258 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 6259 if (element.hasUnitPrice()) 6260 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 6261 if (element.hasFactorElement()) 6262 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 6263 if (element.hasNet()) 6264 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 6265 for (int i = 0; i < element.getUdi().size(); i++) 6266 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 6267 for (int i = 0; i < element.getNoteNumber().size(); i++) 6268 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6269 for (int i = 0; i < element.getAdjudication().size(); i++) 6270 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6271 } 6272 6273 protected void composeExplanationOfBenefitAddedItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemComponent element, int index) { 6274 if (element == null) 6275 return; 6276 Complex t; 6277 if (Utilities.noString(parentType)) 6278 t = parent; 6279 else { 6280 t = parent.predicate("fhir:"+parentType+'.'+name); 6281 } 6282 composeBackboneElement(t, "addItem", name, element, index); 6283 for (int i = 0; i < element.getSequenceLinkId().size(); i++) 6284 composePositiveInt(t, "ExplanationOfBenefit", "sequenceLinkId", element.getSequenceLinkId().get(i), i); 6285 if (element.hasRevenue()) 6286 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6287 if (element.hasCategory()) 6288 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6289 if (element.hasService()) 6290 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6291 for (int i = 0; i < element.getModifier().size(); i++) 6292 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6293 if (element.hasFee()) 6294 composeMoney(t, "ExplanationOfBenefit", "fee", element.getFee(), -1); 6295 for (int i = 0; i < element.getNoteNumber().size(); i++) 6296 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6297 for (int i = 0; i < element.getAdjudication().size(); i++) 6298 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6299 for (int i = 0; i < element.getDetail().size(); i++) 6300 composeExplanationOfBenefitAddedItemsDetailComponent(t, "ExplanationOfBenefit", "detail", element.getDetail().get(i), i); 6301 } 6302 6303 protected void composeExplanationOfBenefitAddedItemsDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemsDetailComponent element, int index) { 6304 if (element == null) 6305 return; 6306 Complex t; 6307 if (Utilities.noString(parentType)) 6308 t = parent; 6309 else { 6310 t = parent.predicate("fhir:"+parentType+'.'+name); 6311 } 6312 composeBackboneElement(t, "detail", name, element, index); 6313 if (element.hasRevenue()) 6314 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6315 if (element.hasCategory()) 6316 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6317 if (element.hasService()) 6318 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6319 for (int i = 0; i < element.getModifier().size(); i++) 6320 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6321 if (element.hasFee()) 6322 composeMoney(t, "ExplanationOfBenefit", "fee", element.getFee(), -1); 6323 for (int i = 0; i < element.getNoteNumber().size(); i++) 6324 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6325 for (int i = 0; i < element.getAdjudication().size(); i++) 6326 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6327 } 6328 6329 protected void composeExplanationOfBenefitPaymentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PaymentComponent element, int index) { 6330 if (element == null) 6331 return; 6332 Complex t; 6333 if (Utilities.noString(parentType)) 6334 t = parent; 6335 else { 6336 t = parent.predicate("fhir:"+parentType+'.'+name); 6337 } 6338 composeBackboneElement(t, "payment", name, element, index); 6339 if (element.hasType()) 6340 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6341 if (element.hasAdjustment()) 6342 composeMoney(t, "ExplanationOfBenefit", "adjustment", element.getAdjustment(), -1); 6343 if (element.hasAdjustmentReason()) 6344 composeCodeableConcept(t, "ExplanationOfBenefit", "adjustmentReason", element.getAdjustmentReason(), -1); 6345 if (element.hasDateElement()) 6346 composeDate(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1); 6347 if (element.hasAmount()) 6348 composeMoney(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1); 6349 if (element.hasIdentifier()) 6350 composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier(), -1); 6351 } 6352 6353 protected void composeExplanationOfBenefitNoteComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.NoteComponent element, int index) { 6354 if (element == null) 6355 return; 6356 Complex t; 6357 if (Utilities.noString(parentType)) 6358 t = parent; 6359 else { 6360 t = parent.predicate("fhir:"+parentType+'.'+name); 6361 } 6362 composeBackboneElement(t, "processNote", name, element, index); 6363 if (element.hasNumberElement()) 6364 composePositiveInt(t, "ExplanationOfBenefit", "number", element.getNumberElement(), -1); 6365 if (element.hasType()) 6366 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6367 if (element.hasTextElement()) 6368 composeString(t, "ExplanationOfBenefit", "text", element.getTextElement(), -1); 6369 if (element.hasLanguage()) 6370 composeCodeableConcept(t, "ExplanationOfBenefit", "language", element.getLanguage(), -1); 6371 } 6372 6373 protected void composeExplanationOfBenefitBenefitBalanceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitBalanceComponent element, int index) { 6374 if (element == null) 6375 return; 6376 Complex t; 6377 if (Utilities.noString(parentType)) 6378 t = parent; 6379 else { 6380 t = parent.predicate("fhir:"+parentType+'.'+name); 6381 } 6382 composeBackboneElement(t, "benefitBalance", name, element, index); 6383 if (element.hasCategory()) 6384 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6385 if (element.hasSubCategory()) 6386 composeCodeableConcept(t, "ExplanationOfBenefit", "subCategory", element.getSubCategory(), -1); 6387 if (element.hasExcludedElement()) 6388 composeBoolean(t, "ExplanationOfBenefit", "excluded", element.getExcludedElement(), -1); 6389 if (element.hasNameElement()) 6390 composeString(t, "ExplanationOfBenefit", "name", element.getNameElement(), -1); 6391 if (element.hasDescriptionElement()) 6392 composeString(t, "ExplanationOfBenefit", "description", element.getDescriptionElement(), -1); 6393 if (element.hasNetwork()) 6394 composeCodeableConcept(t, "ExplanationOfBenefit", "network", element.getNetwork(), -1); 6395 if (element.hasUnit()) 6396 composeCodeableConcept(t, "ExplanationOfBenefit", "unit", element.getUnit(), -1); 6397 if (element.hasTerm()) 6398 composeCodeableConcept(t, "ExplanationOfBenefit", "term", element.getTerm(), -1); 6399 for (int i = 0; i < element.getFinancial().size(); i++) 6400 composeExplanationOfBenefitBenefitComponent(t, "ExplanationOfBenefit", "financial", element.getFinancial().get(i), i); 6401 } 6402 6403 protected void composeExplanationOfBenefitBenefitComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitComponent 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:"+parentType+'.'+name); 6411 } 6412 composeBackboneElement(t, "financial", name, element, index); 6413 if (element.hasType()) 6414 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6415 if (element.hasAllowed()) 6416 composeType(t, "ExplanationOfBenefit", "allowed", element.getAllowed(), -1); 6417 if (element.hasUsed()) 6418 composeType(t, "ExplanationOfBenefit", "used", element.getUsed(), -1); 6419 } 6420 6421 protected void composeFamilyMemberHistory(Complex parent, String parentType, String name, FamilyMemberHistory element, int index) { 6422 if (element == null) 6423 return; 6424 Complex t; 6425 if (Utilities.noString(parentType)) 6426 t = parent; 6427 else { 6428 t = parent.predicate("fhir:"+parentType+'.'+name); 6429 } 6430 composeDomainResource(t, "FamilyMemberHistory", name, element, index); 6431 for (int i = 0; i < element.getIdentifier().size(); i++) 6432 composeIdentifier(t, "FamilyMemberHistory", "identifier", element.getIdentifier().get(i), i); 6433 for (int i = 0; i < element.getDefinition().size(); i++) 6434 composeReference(t, "FamilyMemberHistory", "definition", element.getDefinition().get(i), i); 6435 if (element.hasStatusElement()) 6436 composeEnum(t, "FamilyMemberHistory", "status", element.getStatusElement(), -1); 6437 if (element.hasNotDoneElement()) 6438 composeBoolean(t, "FamilyMemberHistory", "notDone", element.getNotDoneElement(), -1); 6439 if (element.hasNotDoneReason()) 6440 composeCodeableConcept(t, "FamilyMemberHistory", "notDoneReason", element.getNotDoneReason(), -1); 6441 if (element.hasPatient()) 6442 composeReference(t, "FamilyMemberHistory", "patient", element.getPatient(), -1); 6443 if (element.hasDateElement()) 6444 composeDateTime(t, "FamilyMemberHistory", "date", element.getDateElement(), -1); 6445 if (element.hasNameElement()) 6446 composeString(t, "FamilyMemberHistory", "name", element.getNameElement(), -1); 6447 if (element.hasRelationship()) 6448 composeCodeableConcept(t, "FamilyMemberHistory", "relationship", element.getRelationship(), -1); 6449 if (element.hasGenderElement()) 6450 composeEnum(t, "FamilyMemberHistory", "gender", element.getGenderElement(), -1); 6451 if (element.hasBorn()) 6452 composeType(t, "FamilyMemberHistory", "born", element.getBorn(), -1); 6453 if (element.hasAge()) 6454 composeType(t, "FamilyMemberHistory", "age", element.getAge(), -1); 6455 if (element.hasEstimatedAgeElement()) 6456 composeBoolean(t, "FamilyMemberHistory", "estimatedAge", element.getEstimatedAgeElement(), -1); 6457 if (element.hasDeceased()) 6458 composeType(t, "FamilyMemberHistory", "deceased", element.getDeceased(), -1); 6459 for (int i = 0; i < element.getReasonCode().size(); i++) 6460 composeCodeableConcept(t, "FamilyMemberHistory", "reasonCode", element.getReasonCode().get(i), i); 6461 for (int i = 0; i < element.getReasonReference().size(); i++) 6462 composeReference(t, "FamilyMemberHistory", "reasonReference", element.getReasonReference().get(i), i); 6463 for (int i = 0; i < element.getNote().size(); i++) 6464 composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i); 6465 for (int i = 0; i < element.getCondition().size(); i++) 6466 composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(t, "FamilyMemberHistory", "condition", element.getCondition().get(i), i); 6467 } 6468 6469 protected void composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryConditionComponent element, int index) { 6470 if (element == null) 6471 return; 6472 Complex t; 6473 if (Utilities.noString(parentType)) 6474 t = parent; 6475 else { 6476 t = parent.predicate("fhir:"+parentType+'.'+name); 6477 } 6478 composeBackboneElement(t, "condition", name, element, index); 6479 if (element.hasCode()) 6480 composeCodeableConcept(t, "FamilyMemberHistory", "code", element.getCode(), -1); 6481 if (element.hasOutcome()) 6482 composeCodeableConcept(t, "FamilyMemberHistory", "outcome", element.getOutcome(), -1); 6483 if (element.hasOnset()) 6484 composeType(t, "FamilyMemberHistory", "onset", element.getOnset(), -1); 6485 for (int i = 0; i < element.getNote().size(); i++) 6486 composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i); 6487 } 6488 6489 protected void composeFlag(Complex parent, String parentType, String name, Flag element, int index) { 6490 if (element == null) 6491 return; 6492 Complex t; 6493 if (Utilities.noString(parentType)) 6494 t = parent; 6495 else { 6496 t = parent.predicate("fhir:"+parentType+'.'+name); 6497 } 6498 composeDomainResource(t, "Flag", name, element, index); 6499 for (int i = 0; i < element.getIdentifier().size(); i++) 6500 composeIdentifier(t, "Flag", "identifier", element.getIdentifier().get(i), i); 6501 if (element.hasStatusElement()) 6502 composeEnum(t, "Flag", "status", element.getStatusElement(), -1); 6503 if (element.hasCategory()) 6504 composeCodeableConcept(t, "Flag", "category", element.getCategory(), -1); 6505 if (element.hasCode()) 6506 composeCodeableConcept(t, "Flag", "code", element.getCode(), -1); 6507 if (element.hasSubject()) 6508 composeReference(t, "Flag", "subject", element.getSubject(), -1); 6509 if (element.hasPeriod()) 6510 composePeriod(t, "Flag", "period", element.getPeriod(), -1); 6511 if (element.hasEncounter()) 6512 composeReference(t, "Flag", "encounter", element.getEncounter(), -1); 6513 if (element.hasAuthor()) 6514 composeReference(t, "Flag", "author", element.getAuthor(), -1); 6515 } 6516 6517 protected void composeGoal(Complex parent, String parentType, String name, Goal element, int index) { 6518 if (element == null) 6519 return; 6520 Complex t; 6521 if (Utilities.noString(parentType)) 6522 t = parent; 6523 else { 6524 t = parent.predicate("fhir:"+parentType+'.'+name); 6525 } 6526 composeDomainResource(t, "Goal", name, element, index); 6527 for (int i = 0; i < element.getIdentifier().size(); i++) 6528 composeIdentifier(t, "Goal", "identifier", element.getIdentifier().get(i), i); 6529 if (element.hasStatusElement()) 6530 composeEnum(t, "Goal", "status", element.getStatusElement(), -1); 6531 for (int i = 0; i < element.getCategory().size(); i++) 6532 composeCodeableConcept(t, "Goal", "category", element.getCategory().get(i), i); 6533 if (element.hasPriority()) 6534 composeCodeableConcept(t, "Goal", "priority", element.getPriority(), -1); 6535 if (element.hasDescription()) 6536 composeCodeableConcept(t, "Goal", "description", element.getDescription(), -1); 6537 if (element.hasSubject()) 6538 composeReference(t, "Goal", "subject", element.getSubject(), -1); 6539 if (element.hasStart()) 6540 composeType(t, "Goal", "start", element.getStart(), -1); 6541 if (element.hasTarget()) 6542 composeGoalGoalTargetComponent(t, "Goal", "target", element.getTarget(), -1); 6543 if (element.hasStatusDateElement()) 6544 composeDate(t, "Goal", "statusDate", element.getStatusDateElement(), -1); 6545 if (element.hasStatusReasonElement()) 6546 composeString(t, "Goal", "statusReason", element.getStatusReasonElement(), -1); 6547 if (element.hasExpressedBy()) 6548 composeReference(t, "Goal", "expressedBy", element.getExpressedBy(), -1); 6549 for (int i = 0; i < element.getAddresses().size(); i++) 6550 composeReference(t, "Goal", "addresses", element.getAddresses().get(i), i); 6551 for (int i = 0; i < element.getNote().size(); i++) 6552 composeAnnotation(t, "Goal", "note", element.getNote().get(i), i); 6553 for (int i = 0; i < element.getOutcomeCode().size(); i++) 6554 composeCodeableConcept(t, "Goal", "outcomeCode", element.getOutcomeCode().get(i), i); 6555 for (int i = 0; i < element.getOutcomeReference().size(); i++) 6556 composeReference(t, "Goal", "outcomeReference", element.getOutcomeReference().get(i), i); 6557 } 6558 6559 protected void composeGoalGoalTargetComponent(Complex parent, String parentType, String name, Goal.GoalTargetComponent element, int index) { 6560 if (element == null) 6561 return; 6562 Complex t; 6563 if (Utilities.noString(parentType)) 6564 t = parent; 6565 else { 6566 t = parent.predicate("fhir:"+parentType+'.'+name); 6567 } 6568 composeBackboneElement(t, "target", name, element, index); 6569 if (element.hasMeasure()) 6570 composeCodeableConcept(t, "Goal", "measure", element.getMeasure(), -1); 6571 if (element.hasDetail()) 6572 composeType(t, "Goal", "detail", element.getDetail(), -1); 6573 if (element.hasDue()) 6574 composeType(t, "Goal", "due", element.getDue(), -1); 6575 } 6576 6577 protected void composeGraphDefinition(Complex parent, String parentType, String name, GraphDefinition element, int index) { 6578 if (element == null) 6579 return; 6580 Complex t; 6581 if (Utilities.noString(parentType)) 6582 t = parent; 6583 else { 6584 t = parent.predicate("fhir:"+parentType+'.'+name); 6585 } 6586 composeDomainResource(t, "GraphDefinition", name, element, index); 6587 if (element.hasUrlElement()) 6588 composeUri(t, "GraphDefinition", "url", element.getUrlElement(), -1); 6589 if (element.hasVersionElement()) 6590 composeString(t, "GraphDefinition", "version", element.getVersionElement(), -1); 6591 if (element.hasNameElement()) 6592 composeString(t, "GraphDefinition", "name", element.getNameElement(), -1); 6593 if (element.hasStatusElement()) 6594 composeEnum(t, "GraphDefinition", "status", element.getStatusElement(), -1); 6595 if (element.hasExperimentalElement()) 6596 composeBoolean(t, "GraphDefinition", "experimental", element.getExperimentalElement(), -1); 6597 if (element.hasDateElement()) 6598 composeDateTime(t, "GraphDefinition", "date", element.getDateElement(), -1); 6599 if (element.hasPublisherElement()) 6600 composeString(t, "GraphDefinition", "publisher", element.getPublisherElement(), -1); 6601 for (int i = 0; i < element.getContact().size(); i++) 6602 composeContactDetail(t, "GraphDefinition", "contact", element.getContact().get(i), i); 6603 if (element.hasDescriptionElement()) 6604 composeMarkdown(t, "GraphDefinition", "description", element.getDescriptionElement(), -1); 6605 for (int i = 0; i < element.getUseContext().size(); i++) 6606 composeUsageContext(t, "GraphDefinition", "useContext", element.getUseContext().get(i), i); 6607 for (int i = 0; i < element.getJurisdiction().size(); i++) 6608 composeCodeableConcept(t, "GraphDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 6609 if (element.hasPurposeElement()) 6610 composeMarkdown(t, "GraphDefinition", "purpose", element.getPurposeElement(), -1); 6611 if (element.hasStartElement()) 6612 composeCode(t, "GraphDefinition", "start", element.getStartElement(), -1); 6613 if (element.hasProfileElement()) 6614 composeUri(t, "GraphDefinition", "profile", element.getProfileElement(), -1); 6615 for (int i = 0; i < element.getLink().size(); i++) 6616 composeGraphDefinitionGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i); 6617 } 6618 6619 protected void composeGraphDefinitionGraphDefinitionLinkComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkComponent element, int index) { 6620 if (element == null) 6621 return; 6622 Complex t; 6623 if (Utilities.noString(parentType)) 6624 t = parent; 6625 else { 6626 t = parent.predicate("fhir:"+parentType+'.'+name); 6627 } 6628 composeBackboneElement(t, "link", name, element, index); 6629 if (element.hasPathElement()) 6630 composeString(t, "GraphDefinition", "path", element.getPathElement(), -1); 6631 if (element.hasSliceNameElement()) 6632 composeString(t, "GraphDefinition", "sliceName", element.getSliceNameElement(), -1); 6633 if (element.hasMinElement()) 6634 composeInteger(t, "GraphDefinition", "min", element.getMinElement(), -1); 6635 if (element.hasMaxElement()) 6636 composeString(t, "GraphDefinition", "max", element.getMaxElement(), -1); 6637 if (element.hasDescriptionElement()) 6638 composeString(t, "GraphDefinition", "description", element.getDescriptionElement(), -1); 6639 for (int i = 0; i < element.getTarget().size(); i++) 6640 composeGraphDefinitionGraphDefinitionLinkTargetComponent(t, "GraphDefinition", "target", element.getTarget().get(i), i); 6641 } 6642 6643 protected void composeGraphDefinitionGraphDefinitionLinkTargetComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetComponent element, int index) { 6644 if (element == null) 6645 return; 6646 Complex t; 6647 if (Utilities.noString(parentType)) 6648 t = parent; 6649 else { 6650 t = parent.predicate("fhir:"+parentType+'.'+name); 6651 } 6652 composeBackboneElement(t, "target", name, element, index); 6653 if (element.hasTypeElement()) 6654 composeCode(t, "GraphDefinition", "type", element.getTypeElement(), -1); 6655 if (element.hasProfileElement()) 6656 composeUri(t, "GraphDefinition", "profile", element.getProfileElement(), -1); 6657 for (int i = 0; i < element.getCompartment().size(); i++) 6658 composeGraphDefinitionGraphDefinitionLinkTargetCompartmentComponent(t, "GraphDefinition", "compartment", element.getCompartment().get(i), i); 6659 for (int i = 0; i < element.getLink().size(); i++) 6660 composeGraphDefinitionGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i); 6661 } 6662 6663 protected void composeGraphDefinitionGraphDefinitionLinkTargetCompartmentComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetCompartmentComponent element, int index) { 6664 if (element == null) 6665 return; 6666 Complex t; 6667 if (Utilities.noString(parentType)) 6668 t = parent; 6669 else { 6670 t = parent.predicate("fhir:"+parentType+'.'+name); 6671 } 6672 composeBackboneElement(t, "compartment", name, element, index); 6673 if (element.hasCodeElement()) 6674 composeEnum(t, "GraphDefinition", "code", element.getCodeElement(), -1); 6675 if (element.hasRuleElement()) 6676 composeEnum(t, "GraphDefinition", "rule", element.getRuleElement(), -1); 6677 if (element.hasExpressionElement()) 6678 composeString(t, "GraphDefinition", "expression", element.getExpressionElement(), -1); 6679 if (element.hasDescriptionElement()) 6680 composeString(t, "GraphDefinition", "description", element.getDescriptionElement(), -1); 6681 } 6682 6683 protected void composeGroup(Complex parent, String parentType, String name, Group element, int index) { 6684 if (element == null) 6685 return; 6686 Complex t; 6687 if (Utilities.noString(parentType)) 6688 t = parent; 6689 else { 6690 t = parent.predicate("fhir:"+parentType+'.'+name); 6691 } 6692 composeDomainResource(t, "Group", name, element, index); 6693 for (int i = 0; i < element.getIdentifier().size(); i++) 6694 composeIdentifier(t, "Group", "identifier", element.getIdentifier().get(i), i); 6695 if (element.hasActiveElement()) 6696 composeBoolean(t, "Group", "active", element.getActiveElement(), -1); 6697 if (element.hasTypeElement()) 6698 composeEnum(t, "Group", "type", element.getTypeElement(), -1); 6699 if (element.hasActualElement()) 6700 composeBoolean(t, "Group", "actual", element.getActualElement(), -1); 6701 if (element.hasCode()) 6702 composeCodeableConcept(t, "Group", "code", element.getCode(), -1); 6703 if (element.hasNameElement()) 6704 composeString(t, "Group", "name", element.getNameElement(), -1); 6705 if (element.hasQuantityElement()) 6706 composeUnsignedInt(t, "Group", "quantity", element.getQuantityElement(), -1); 6707 for (int i = 0; i < element.getCharacteristic().size(); i++) 6708 composeGroupGroupCharacteristicComponent(t, "Group", "characteristic", element.getCharacteristic().get(i), i); 6709 for (int i = 0; i < element.getMember().size(); i++) 6710 composeGroupGroupMemberComponent(t, "Group", "member", element.getMember().get(i), i); 6711 } 6712 6713 protected void composeGroupGroupCharacteristicComponent(Complex parent, String parentType, String name, Group.GroupCharacteristicComponent element, int index) { 6714 if (element == null) 6715 return; 6716 Complex t; 6717 if (Utilities.noString(parentType)) 6718 t = parent; 6719 else { 6720 t = parent.predicate("fhir:"+parentType+'.'+name); 6721 } 6722 composeBackboneElement(t, "characteristic", name, element, index); 6723 if (element.hasCode()) 6724 composeCodeableConcept(t, "Group", "code", element.getCode(), -1); 6725 if (element.hasValue()) 6726 composeType(t, "Group", "value", element.getValue(), -1); 6727 if (element.hasExcludeElement()) 6728 composeBoolean(t, "Group", "exclude", element.getExcludeElement(), -1); 6729 if (element.hasPeriod()) 6730 composePeriod(t, "Group", "period", element.getPeriod(), -1); 6731 } 6732 6733 protected void composeGroupGroupMemberComponent(Complex parent, String parentType, String name, Group.GroupMemberComponent element, int index) { 6734 if (element == null) 6735 return; 6736 Complex t; 6737 if (Utilities.noString(parentType)) 6738 t = parent; 6739 else { 6740 t = parent.predicate("fhir:"+parentType+'.'+name); 6741 } 6742 composeBackboneElement(t, "member", name, element, index); 6743 if (element.hasEntity()) 6744 composeReference(t, "Group", "entity", element.getEntity(), -1); 6745 if (element.hasPeriod()) 6746 composePeriod(t, "Group", "period", element.getPeriod(), -1); 6747 if (element.hasInactiveElement()) 6748 composeBoolean(t, "Group", "inactive", element.getInactiveElement(), -1); 6749 } 6750 6751 protected void composeGuidanceResponse(Complex parent, String parentType, String name, GuidanceResponse element, int index) { 6752 if (element == null) 6753 return; 6754 Complex t; 6755 if (Utilities.noString(parentType)) 6756 t = parent; 6757 else { 6758 t = parent.predicate("fhir:"+parentType+'.'+name); 6759 } 6760 composeDomainResource(t, "GuidanceResponse", name, element, index); 6761 if (element.hasRequestIdElement()) 6762 composeId(t, "GuidanceResponse", "requestId", element.getRequestIdElement(), -1); 6763 if (element.hasIdentifier()) 6764 composeIdentifier(t, "GuidanceResponse", "identifier", element.getIdentifier(), -1); 6765 if (element.hasModule()) 6766 composeReference(t, "GuidanceResponse", "module", element.getModule(), -1); 6767 if (element.hasStatusElement()) 6768 composeEnum(t, "GuidanceResponse", "status", element.getStatusElement(), -1); 6769 if (element.hasSubject()) 6770 composeReference(t, "GuidanceResponse", "subject", element.getSubject(), -1); 6771 if (element.hasContext()) 6772 composeReference(t, "GuidanceResponse", "context", element.getContext(), -1); 6773 if (element.hasOccurrenceDateTimeElement()) 6774 composeDateTime(t, "GuidanceResponse", "occurrenceDateTime", element.getOccurrenceDateTimeElement(), -1); 6775 if (element.hasPerformer()) 6776 composeReference(t, "GuidanceResponse", "performer", element.getPerformer(), -1); 6777 if (element.hasReason()) 6778 composeType(t, "GuidanceResponse", "reason", element.getReason(), -1); 6779 for (int i = 0; i < element.getNote().size(); i++) 6780 composeAnnotation(t, "GuidanceResponse", "note", element.getNote().get(i), i); 6781 for (int i = 0; i < element.getEvaluationMessage().size(); i++) 6782 composeReference(t, "GuidanceResponse", "evaluationMessage", element.getEvaluationMessage().get(i), i); 6783 if (element.hasOutputParameters()) 6784 composeReference(t, "GuidanceResponse", "outputParameters", element.getOutputParameters(), -1); 6785 if (element.hasResult()) 6786 composeReference(t, "GuidanceResponse", "result", element.getResult(), -1); 6787 for (int i = 0; i < element.getDataRequirement().size(); i++) 6788 composeDataRequirement(t, "GuidanceResponse", "dataRequirement", element.getDataRequirement().get(i), i); 6789 } 6790 6791 protected void composeHealthcareService(Complex parent, String parentType, String name, HealthcareService element, int index) { 6792 if (element == null) 6793 return; 6794 Complex t; 6795 if (Utilities.noString(parentType)) 6796 t = parent; 6797 else { 6798 t = parent.predicate("fhir:"+parentType+'.'+name); 6799 } 6800 composeDomainResource(t, "HealthcareService", name, element, index); 6801 for (int i = 0; i < element.getIdentifier().size(); i++) 6802 composeIdentifier(t, "HealthcareService", "identifier", element.getIdentifier().get(i), i); 6803 if (element.hasActiveElement()) 6804 composeBoolean(t, "HealthcareService", "active", element.getActiveElement(), -1); 6805 if (element.hasProvidedBy()) 6806 composeReference(t, "HealthcareService", "providedBy", element.getProvidedBy(), -1); 6807 if (element.hasCategory()) 6808 composeCodeableConcept(t, "HealthcareService", "category", element.getCategory(), -1); 6809 for (int i = 0; i < element.getType().size(); i++) 6810 composeCodeableConcept(t, "HealthcareService", "type", element.getType().get(i), i); 6811 for (int i = 0; i < element.getSpecialty().size(); i++) 6812 composeCodeableConcept(t, "HealthcareService", "specialty", element.getSpecialty().get(i), i); 6813 for (int i = 0; i < element.getLocation().size(); i++) 6814 composeReference(t, "HealthcareService", "location", element.getLocation().get(i), i); 6815 if (element.hasNameElement()) 6816 composeString(t, "HealthcareService", "name", element.getNameElement(), -1); 6817 if (element.hasCommentElement()) 6818 composeString(t, "HealthcareService", "comment", element.getCommentElement(), -1); 6819 if (element.hasExtraDetailsElement()) 6820 composeString(t, "HealthcareService", "extraDetails", element.getExtraDetailsElement(), -1); 6821 if (element.hasPhoto()) 6822 composeAttachment(t, "HealthcareService", "photo", element.getPhoto(), -1); 6823 for (int i = 0; i < element.getTelecom().size(); i++) 6824 composeContactPoint(t, "HealthcareService", "telecom", element.getTelecom().get(i), i); 6825 for (int i = 0; i < element.getCoverageArea().size(); i++) 6826 composeReference(t, "HealthcareService", "coverageArea", element.getCoverageArea().get(i), i); 6827 for (int i = 0; i < element.getServiceProvisionCode().size(); i++) 6828 composeCodeableConcept(t, "HealthcareService", "serviceProvisionCode", element.getServiceProvisionCode().get(i), i); 6829 if (element.hasEligibility()) 6830 composeCodeableConcept(t, "HealthcareService", "eligibility", element.getEligibility(), -1); 6831 if (element.hasEligibilityNoteElement()) 6832 composeString(t, "HealthcareService", "eligibilityNote", element.getEligibilityNoteElement(), -1); 6833 for (int i = 0; i < element.getProgramName().size(); i++) 6834 composeString(t, "HealthcareService", "programName", element.getProgramName().get(i), i); 6835 for (int i = 0; i < element.getCharacteristic().size(); i++) 6836 composeCodeableConcept(t, "HealthcareService", "characteristic", element.getCharacteristic().get(i), i); 6837 for (int i = 0; i < element.getReferralMethod().size(); i++) 6838 composeCodeableConcept(t, "HealthcareService", "referralMethod", element.getReferralMethod().get(i), i); 6839 if (element.hasAppointmentRequiredElement()) 6840 composeBoolean(t, "HealthcareService", "appointmentRequired", element.getAppointmentRequiredElement(), -1); 6841 for (int i = 0; i < element.getAvailableTime().size(); i++) 6842 composeHealthcareServiceHealthcareServiceAvailableTimeComponent(t, "HealthcareService", "availableTime", element.getAvailableTime().get(i), i); 6843 for (int i = 0; i < element.getNotAvailable().size(); i++) 6844 composeHealthcareServiceHealthcareServiceNotAvailableComponent(t, "HealthcareService", "notAvailable", element.getNotAvailable().get(i), i); 6845 if (element.hasAvailabilityExceptionsElement()) 6846 composeString(t, "HealthcareService", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1); 6847 for (int i = 0; i < element.getEndpoint().size(); i++) 6848 composeReference(t, "HealthcareService", "endpoint", element.getEndpoint().get(i), i); 6849 } 6850 6851 protected void composeHealthcareServiceHealthcareServiceAvailableTimeComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceAvailableTimeComponent element, int index) { 6852 if (element == null) 6853 return; 6854 Complex t; 6855 if (Utilities.noString(parentType)) 6856 t = parent; 6857 else { 6858 t = parent.predicate("fhir:"+parentType+'.'+name); 6859 } 6860 composeBackboneElement(t, "availableTime", name, element, index); 6861 for (int i = 0; i < element.getDaysOfWeek().size(); i++) 6862 composeEnum(t, "HealthcareService", "daysOfWeek", element.getDaysOfWeek().get(i), i); 6863 if (element.hasAllDayElement()) 6864 composeBoolean(t, "HealthcareService", "allDay", element.getAllDayElement(), -1); 6865 if (element.hasAvailableStartTimeElement()) 6866 composeTime(t, "HealthcareService", "availableStartTime", element.getAvailableStartTimeElement(), -1); 6867 if (element.hasAvailableEndTimeElement()) 6868 composeTime(t, "HealthcareService", "availableEndTime", element.getAvailableEndTimeElement(), -1); 6869 } 6870 6871 protected void composeHealthcareServiceHealthcareServiceNotAvailableComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceNotAvailableComponent element, int index) { 6872 if (element == null) 6873 return; 6874 Complex t; 6875 if (Utilities.noString(parentType)) 6876 t = parent; 6877 else { 6878 t = parent.predicate("fhir:"+parentType+'.'+name); 6879 } 6880 composeBackboneElement(t, "notAvailable", name, element, index); 6881 if (element.hasDescriptionElement()) 6882 composeString(t, "HealthcareService", "description", element.getDescriptionElement(), -1); 6883 if (element.hasDuring()) 6884 composePeriod(t, "HealthcareService", "during", element.getDuring(), -1); 6885 } 6886 6887 protected void composeImagingManifest(Complex parent, String parentType, String name, ImagingManifest element, int index) { 6888 if (element == null) 6889 return; 6890 Complex t; 6891 if (Utilities.noString(parentType)) 6892 t = parent; 6893 else { 6894 t = parent.predicate("fhir:"+parentType+'.'+name); 6895 } 6896 composeDomainResource(t, "ImagingManifest", name, element, index); 6897 if (element.hasIdentifier()) 6898 composeIdentifier(t, "ImagingManifest", "identifier", element.getIdentifier(), -1); 6899 if (element.hasPatient()) 6900 composeReference(t, "ImagingManifest", "patient", element.getPatient(), -1); 6901 if (element.hasAuthoringTimeElement()) 6902 composeDateTime(t, "ImagingManifest", "authoringTime", element.getAuthoringTimeElement(), -1); 6903 if (element.hasAuthor()) 6904 composeReference(t, "ImagingManifest", "author", element.getAuthor(), -1); 6905 if (element.hasDescriptionElement()) 6906 composeString(t, "ImagingManifest", "description", element.getDescriptionElement(), -1); 6907 for (int i = 0; i < element.getStudy().size(); i++) 6908 composeImagingManifestStudyComponent(t, "ImagingManifest", "study", element.getStudy().get(i), i); 6909 } 6910 6911 protected void composeImagingManifestStudyComponent(Complex parent, String parentType, String name, ImagingManifest.StudyComponent element, int index) { 6912 if (element == null) 6913 return; 6914 Complex t; 6915 if (Utilities.noString(parentType)) 6916 t = parent; 6917 else { 6918 t = parent.predicate("fhir:"+parentType+'.'+name); 6919 } 6920 composeBackboneElement(t, "study", name, element, index); 6921 if (element.hasUidElement()) 6922 composeOid(t, "ImagingManifest", "uid", element.getUidElement(), -1); 6923 if (element.hasImagingStudy()) 6924 composeReference(t, "ImagingManifest", "imagingStudy", element.getImagingStudy(), -1); 6925 for (int i = 0; i < element.getEndpoint().size(); i++) 6926 composeReference(t, "ImagingManifest", "endpoint", element.getEndpoint().get(i), i); 6927 for (int i = 0; i < element.getSeries().size(); i++) 6928 composeImagingManifestSeriesComponent(t, "ImagingManifest", "series", element.getSeries().get(i), i); 6929 } 6930 6931 protected void composeImagingManifestSeriesComponent(Complex parent, String parentType, String name, ImagingManifest.SeriesComponent element, int index) { 6932 if (element == null) 6933 return; 6934 Complex t; 6935 if (Utilities.noString(parentType)) 6936 t = parent; 6937 else { 6938 t = parent.predicate("fhir:"+parentType+'.'+name); 6939 } 6940 composeBackboneElement(t, "series", name, element, index); 6941 if (element.hasUidElement()) 6942 composeOid(t, "ImagingManifest", "uid", element.getUidElement(), -1); 6943 for (int i = 0; i < element.getEndpoint().size(); i++) 6944 composeReference(t, "ImagingManifest", "endpoint", element.getEndpoint().get(i), i); 6945 for (int i = 0; i < element.getInstance().size(); i++) 6946 composeImagingManifestInstanceComponent(t, "ImagingManifest", "instance", element.getInstance().get(i), i); 6947 } 6948 6949 protected void composeImagingManifestInstanceComponent(Complex parent, String parentType, String name, ImagingManifest.InstanceComponent element, int index) { 6950 if (element == null) 6951 return; 6952 Complex t; 6953 if (Utilities.noString(parentType)) 6954 t = parent; 6955 else { 6956 t = parent.predicate("fhir:"+parentType+'.'+name); 6957 } 6958 composeBackboneElement(t, "instance", name, element, index); 6959 if (element.hasSopClassElement()) 6960 composeOid(t, "ImagingManifest", "sopClass", element.getSopClassElement(), -1); 6961 if (element.hasUidElement()) 6962 composeOid(t, "ImagingManifest", "uid", element.getUidElement(), -1); 6963 } 6964 6965 protected void composeImagingStudy(Complex parent, String parentType, String name, ImagingStudy element, int index) { 6966 if (element == null) 6967 return; 6968 Complex t; 6969 if (Utilities.noString(parentType)) 6970 t = parent; 6971 else { 6972 t = parent.predicate("fhir:"+parentType+'.'+name); 6973 } 6974 composeDomainResource(t, "ImagingStudy", name, element, index); 6975 if (element.hasUidElement()) 6976 composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1); 6977 if (element.hasAccession()) 6978 composeIdentifier(t, "ImagingStudy", "accession", element.getAccession(), -1); 6979 for (int i = 0; i < element.getIdentifier().size(); i++) 6980 composeIdentifier(t, "ImagingStudy", "identifier", element.getIdentifier().get(i), i); 6981 if (element.hasAvailabilityElement()) 6982 composeEnum(t, "ImagingStudy", "availability", element.getAvailabilityElement(), -1); 6983 for (int i = 0; i < element.getModalityList().size(); i++) 6984 composeCoding(t, "ImagingStudy", "modalityList", element.getModalityList().get(i), i); 6985 if (element.hasPatient()) 6986 composeReference(t, "ImagingStudy", "patient", element.getPatient(), -1); 6987 if (element.hasContext()) 6988 composeReference(t, "ImagingStudy", "context", element.getContext(), -1); 6989 if (element.hasStartedElement()) 6990 composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1); 6991 for (int i = 0; i < element.getBasedOn().size(); i++) 6992 composeReference(t, "ImagingStudy", "basedOn", element.getBasedOn().get(i), i); 6993 if (element.hasReferrer()) 6994 composeReference(t, "ImagingStudy", "referrer", element.getReferrer(), -1); 6995 for (int i = 0; i < element.getInterpreter().size(); i++) 6996 composeReference(t, "ImagingStudy", "interpreter", element.getInterpreter().get(i), i); 6997 for (int i = 0; i < element.getEndpoint().size(); i++) 6998 composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i); 6999 if (element.hasNumberOfSeriesElement()) 7000 composeUnsignedInt(t, "ImagingStudy", "numberOfSeries", element.getNumberOfSeriesElement(), -1); 7001 if (element.hasNumberOfInstancesElement()) 7002 composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1); 7003 for (int i = 0; i < element.getProcedureReference().size(); i++) 7004 composeReference(t, "ImagingStudy", "procedureReference", element.getProcedureReference().get(i), i); 7005 for (int i = 0; i < element.getProcedureCode().size(); i++) 7006 composeCodeableConcept(t, "ImagingStudy", "procedureCode", element.getProcedureCode().get(i), i); 7007 if (element.hasReason()) 7008 composeCodeableConcept(t, "ImagingStudy", "reason", element.getReason(), -1); 7009 if (element.hasDescriptionElement()) 7010 composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1); 7011 for (int i = 0; i < element.getSeries().size(); i++) 7012 composeImagingStudyImagingStudySeriesComponent(t, "ImagingStudy", "series", element.getSeries().get(i), i); 7013 } 7014 7015 protected void composeImagingStudyImagingStudySeriesComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesComponent element, int index) { 7016 if (element == null) 7017 return; 7018 Complex t; 7019 if (Utilities.noString(parentType)) 7020 t = parent; 7021 else { 7022 t = parent.predicate("fhir:"+parentType+'.'+name); 7023 } 7024 composeBackboneElement(t, "series", name, element, index); 7025 if (element.hasUidElement()) 7026 composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1); 7027 if (element.hasNumberElement()) 7028 composeUnsignedInt(t, "ImagingStudy", "number", element.getNumberElement(), -1); 7029 if (element.hasModality()) 7030 composeCoding(t, "ImagingStudy", "modality", element.getModality(), -1); 7031 if (element.hasDescriptionElement()) 7032 composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1); 7033 if (element.hasNumberOfInstancesElement()) 7034 composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1); 7035 if (element.hasAvailabilityElement()) 7036 composeEnum(t, "ImagingStudy", "availability", element.getAvailabilityElement(), -1); 7037 for (int i = 0; i < element.getEndpoint().size(); i++) 7038 composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i); 7039 if (element.hasBodySite()) 7040 composeCoding(t, "ImagingStudy", "bodySite", element.getBodySite(), -1); 7041 if (element.hasLaterality()) 7042 composeCoding(t, "ImagingStudy", "laterality", element.getLaterality(), -1); 7043 if (element.hasStartedElement()) 7044 composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1); 7045 for (int i = 0; i < element.getPerformer().size(); i++) 7046 composeReference(t, "ImagingStudy", "performer", element.getPerformer().get(i), i); 7047 for (int i = 0; i < element.getInstance().size(); i++) 7048 composeImagingStudyImagingStudySeriesInstanceComponent(t, "ImagingStudy", "instance", element.getInstance().get(i), i); 7049 } 7050 7051 protected void composeImagingStudyImagingStudySeriesInstanceComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesInstanceComponent element, int index) { 7052 if (element == null) 7053 return; 7054 Complex t; 7055 if (Utilities.noString(parentType)) 7056 t = parent; 7057 else { 7058 t = parent.predicate("fhir:"+parentType+'.'+name); 7059 } 7060 composeBackboneElement(t, "instance", name, element, index); 7061 if (element.hasUidElement()) 7062 composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1); 7063 if (element.hasNumberElement()) 7064 composeUnsignedInt(t, "ImagingStudy", "number", element.getNumberElement(), -1); 7065 if (element.hasSopClassElement()) 7066 composeOid(t, "ImagingStudy", "sopClass", element.getSopClassElement(), -1); 7067 if (element.hasTitleElement()) 7068 composeString(t, "ImagingStudy", "title", element.getTitleElement(), -1); 7069 } 7070 7071 protected void composeImmunization(Complex parent, String parentType, String name, Immunization element, int index) { 7072 if (element == null) 7073 return; 7074 Complex t; 7075 if (Utilities.noString(parentType)) 7076 t = parent; 7077 else { 7078 t = parent.predicate("fhir:"+parentType+'.'+name); 7079 } 7080 composeDomainResource(t, "Immunization", name, element, index); 7081 for (int i = 0; i < element.getIdentifier().size(); i++) 7082 composeIdentifier(t, "Immunization", "identifier", element.getIdentifier().get(i), i); 7083 if (element.hasStatusElement()) 7084 composeEnum(t, "Immunization", "status", element.getStatusElement(), -1); 7085 if (element.hasNotGivenElement()) 7086 composeBoolean(t, "Immunization", "notGiven", element.getNotGivenElement(), -1); 7087 if (element.hasVaccineCode()) 7088 composeCodeableConcept(t, "Immunization", "vaccineCode", element.getVaccineCode(), -1); 7089 if (element.hasPatient()) 7090 composeReference(t, "Immunization", "patient", element.getPatient(), -1); 7091 if (element.hasEncounter()) 7092 composeReference(t, "Immunization", "encounter", element.getEncounter(), -1); 7093 if (element.hasDateElement()) 7094 composeDateTime(t, "Immunization", "date", element.getDateElement(), -1); 7095 if (element.hasPrimarySourceElement()) 7096 composeBoolean(t, "Immunization", "primarySource", element.getPrimarySourceElement(), -1); 7097 if (element.hasReportOrigin()) 7098 composeCodeableConcept(t, "Immunization", "reportOrigin", element.getReportOrigin(), -1); 7099 if (element.hasLocation()) 7100 composeReference(t, "Immunization", "location", element.getLocation(), -1); 7101 if (element.hasManufacturer()) 7102 composeReference(t, "Immunization", "manufacturer", element.getManufacturer(), -1); 7103 if (element.hasLotNumberElement()) 7104 composeString(t, "Immunization", "lotNumber", element.getLotNumberElement(), -1); 7105 if (element.hasExpirationDateElement()) 7106 composeDate(t, "Immunization", "expirationDate", element.getExpirationDateElement(), -1); 7107 if (element.hasSite()) 7108 composeCodeableConcept(t, "Immunization", "site", element.getSite(), -1); 7109 if (element.hasRoute()) 7110 composeCodeableConcept(t, "Immunization", "route", element.getRoute(), -1); 7111 if (element.hasDoseQuantity()) 7112 composeQuantity(t, "Immunization", "doseQuantity", element.getDoseQuantity(), -1); 7113 for (int i = 0; i < element.getPractitioner().size(); i++) 7114 composeImmunizationImmunizationPractitionerComponent(t, "Immunization", "practitioner", element.getPractitioner().get(i), i); 7115 for (int i = 0; i < element.getNote().size(); i++) 7116 composeAnnotation(t, "Immunization", "note", element.getNote().get(i), i); 7117 if (element.hasExplanation()) 7118 composeImmunizationImmunizationExplanationComponent(t, "Immunization", "explanation", element.getExplanation(), -1); 7119 for (int i = 0; i < element.getReaction().size(); i++) 7120 composeImmunizationImmunizationReactionComponent(t, "Immunization", "reaction", element.getReaction().get(i), i); 7121 for (int i = 0; i < element.getVaccinationProtocol().size(); i++) 7122 composeImmunizationImmunizationVaccinationProtocolComponent(t, "Immunization", "vaccinationProtocol", element.getVaccinationProtocol().get(i), i); 7123 } 7124 7125 protected void composeImmunizationImmunizationPractitionerComponent(Complex parent, String parentType, String name, Immunization.ImmunizationPractitionerComponent element, int index) { 7126 if (element == null) 7127 return; 7128 Complex t; 7129 if (Utilities.noString(parentType)) 7130 t = parent; 7131 else { 7132 t = parent.predicate("fhir:"+parentType+'.'+name); 7133 } 7134 composeBackboneElement(t, "practitioner", name, element, index); 7135 if (element.hasRole()) 7136 composeCodeableConcept(t, "Immunization", "role", element.getRole(), -1); 7137 if (element.hasActor()) 7138 composeReference(t, "Immunization", "actor", element.getActor(), -1); 7139 } 7140 7141 protected void composeImmunizationImmunizationExplanationComponent(Complex parent, String parentType, String name, Immunization.ImmunizationExplanationComponent element, int index) { 7142 if (element == null) 7143 return; 7144 Complex t; 7145 if (Utilities.noString(parentType)) 7146 t = parent; 7147 else { 7148 t = parent.predicate("fhir:"+parentType+'.'+name); 7149 } 7150 composeBackboneElement(t, "explanation", name, element, index); 7151 for (int i = 0; i < element.getReason().size(); i++) 7152 composeCodeableConcept(t, "Immunization", "reason", element.getReason().get(i), i); 7153 for (int i = 0; i < element.getReasonNotGiven().size(); i++) 7154 composeCodeableConcept(t, "Immunization", "reasonNotGiven", element.getReasonNotGiven().get(i), i); 7155 } 7156 7157 protected void composeImmunizationImmunizationReactionComponent(Complex parent, String parentType, String name, Immunization.ImmunizationReactionComponent element, int index) { 7158 if (element == null) 7159 return; 7160 Complex t; 7161 if (Utilities.noString(parentType)) 7162 t = parent; 7163 else { 7164 t = parent.predicate("fhir:"+parentType+'.'+name); 7165 } 7166 composeBackboneElement(t, "reaction", name, element, index); 7167 if (element.hasDateElement()) 7168 composeDateTime(t, "Immunization", "date", element.getDateElement(), -1); 7169 if (element.hasDetail()) 7170 composeReference(t, "Immunization", "detail", element.getDetail(), -1); 7171 if (element.hasReportedElement()) 7172 composeBoolean(t, "Immunization", "reported", element.getReportedElement(), -1); 7173 } 7174 7175 protected void composeImmunizationImmunizationVaccinationProtocolComponent(Complex parent, String parentType, String name, Immunization.ImmunizationVaccinationProtocolComponent element, int index) { 7176 if (element == null) 7177 return; 7178 Complex t; 7179 if (Utilities.noString(parentType)) 7180 t = parent; 7181 else { 7182 t = parent.predicate("fhir:"+parentType+'.'+name); 7183 } 7184 composeBackboneElement(t, "vaccinationProtocol", name, element, index); 7185 if (element.hasDoseSequenceElement()) 7186 composePositiveInt(t, "Immunization", "doseSequence", element.getDoseSequenceElement(), -1); 7187 if (element.hasDescriptionElement()) 7188 composeString(t, "Immunization", "description", element.getDescriptionElement(), -1); 7189 if (element.hasAuthority()) 7190 composeReference(t, "Immunization", "authority", element.getAuthority(), -1); 7191 if (element.hasSeriesElement()) 7192 composeString(t, "Immunization", "series", element.getSeriesElement(), -1); 7193 if (element.hasSeriesDosesElement()) 7194 composePositiveInt(t, "Immunization", "seriesDoses", element.getSeriesDosesElement(), -1); 7195 for (int i = 0; i < element.getTargetDisease().size(); i++) 7196 composeCodeableConcept(t, "Immunization", "targetDisease", element.getTargetDisease().get(i), i); 7197 if (element.hasDoseStatus()) 7198 composeCodeableConcept(t, "Immunization", "doseStatus", element.getDoseStatus(), -1); 7199 if (element.hasDoseStatusReason()) 7200 composeCodeableConcept(t, "Immunization", "doseStatusReason", element.getDoseStatusReason(), -1); 7201 } 7202 7203 protected void composeImmunizationRecommendation(Complex parent, String parentType, String name, ImmunizationRecommendation element, int index) { 7204 if (element == null) 7205 return; 7206 Complex t; 7207 if (Utilities.noString(parentType)) 7208 t = parent; 7209 else { 7210 t = parent.predicate("fhir:"+parentType+'.'+name); 7211 } 7212 composeDomainResource(t, "ImmunizationRecommendation", name, element, index); 7213 for (int i = 0; i < element.getIdentifier().size(); i++) 7214 composeIdentifier(t, "ImmunizationRecommendation", "identifier", element.getIdentifier().get(i), i); 7215 if (element.hasPatient()) 7216 composeReference(t, "ImmunizationRecommendation", "patient", element.getPatient(), -1); 7217 for (int i = 0; i < element.getRecommendation().size(); i++) 7218 composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(t, "ImmunizationRecommendation", "recommendation", element.getRecommendation().get(i), i); 7219 } 7220 7221 protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent element, int index) { 7222 if (element == null) 7223 return; 7224 Complex t; 7225 if (Utilities.noString(parentType)) 7226 t = parent; 7227 else { 7228 t = parent.predicate("fhir:"+parentType+'.'+name); 7229 } 7230 composeBackboneElement(t, "recommendation", name, element, index); 7231 if (element.hasDateElement()) 7232 composeDateTime(t, "ImmunizationRecommendation", "date", element.getDateElement(), -1); 7233 if (element.hasVaccineCode()) 7234 composeCodeableConcept(t, "ImmunizationRecommendation", "vaccineCode", element.getVaccineCode(), -1); 7235 if (element.hasTargetDisease()) 7236 composeCodeableConcept(t, "ImmunizationRecommendation", "targetDisease", element.getTargetDisease(), -1); 7237 if (element.hasDoseNumberElement()) 7238 composePositiveInt(t, "ImmunizationRecommendation", "doseNumber", element.getDoseNumberElement(), -1); 7239 if (element.hasForecastStatus()) 7240 composeCodeableConcept(t, "ImmunizationRecommendation", "forecastStatus", element.getForecastStatus(), -1); 7241 for (int i = 0; i < element.getDateCriterion().size(); i++) 7242 composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(t, "ImmunizationRecommendation", "dateCriterion", element.getDateCriterion().get(i), i); 7243 if (element.hasProtocol()) 7244 composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(t, "ImmunizationRecommendation", "protocol", element.getProtocol(), -1); 7245 for (int i = 0; i < element.getSupportingImmunization().size(); i++) 7246 composeReference(t, "ImmunizationRecommendation", "supportingImmunization", element.getSupportingImmunization().get(i), i); 7247 for (int i = 0; i < element.getSupportingPatientInformation().size(); i++) 7248 composeReference(t, "ImmunizationRecommendation", "supportingPatientInformation", element.getSupportingPatientInformation().get(i), i); 7249 } 7250 7251 protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent element, int index) { 7252 if (element == null) 7253 return; 7254 Complex t; 7255 if (Utilities.noString(parentType)) 7256 t = parent; 7257 else { 7258 t = parent.predicate("fhir:"+parentType+'.'+name); 7259 } 7260 composeBackboneElement(t, "dateCriterion", name, element, index); 7261 if (element.hasCode()) 7262 composeCodeableConcept(t, "ImmunizationRecommendation", "code", element.getCode(), -1); 7263 if (element.hasValueElement()) 7264 composeDateTime(t, "ImmunizationRecommendation", "value", element.getValueElement(), -1); 7265 } 7266 7267 protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent element, int index) { 7268 if (element == null) 7269 return; 7270 Complex t; 7271 if (Utilities.noString(parentType)) 7272 t = parent; 7273 else { 7274 t = parent.predicate("fhir:"+parentType+'.'+name); 7275 } 7276 composeBackboneElement(t, "protocol", name, element, index); 7277 if (element.hasDoseSequenceElement()) 7278 composePositiveInt(t, "ImmunizationRecommendation", "doseSequence", element.getDoseSequenceElement(), -1); 7279 if (element.hasDescriptionElement()) 7280 composeString(t, "ImmunizationRecommendation", "description", element.getDescriptionElement(), -1); 7281 if (element.hasAuthority()) 7282 composeReference(t, "ImmunizationRecommendation", "authority", element.getAuthority(), -1); 7283 if (element.hasSeriesElement()) 7284 composeString(t, "ImmunizationRecommendation", "series", element.getSeriesElement(), -1); 7285 } 7286 7287 protected void composeImplementationGuide(Complex parent, String parentType, String name, ImplementationGuide element, int index) { 7288 if (element == null) 7289 return; 7290 Complex t; 7291 if (Utilities.noString(parentType)) 7292 t = parent; 7293 else { 7294 t = parent.predicate("fhir:"+parentType+'.'+name); 7295 } 7296 composeDomainResource(t, "ImplementationGuide", name, element, index); 7297 if (element.hasUrlElement()) 7298 composeUri(t, "ImplementationGuide", "url", element.getUrlElement(), -1); 7299 if (element.hasVersionElement()) 7300 composeString(t, "ImplementationGuide", "version", element.getVersionElement(), -1); 7301 if (element.hasNameElement()) 7302 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 7303 if (element.hasStatusElement()) 7304 composeEnum(t, "ImplementationGuide", "status", element.getStatusElement(), -1); 7305 if (element.hasExperimentalElement()) 7306 composeBoolean(t, "ImplementationGuide", "experimental", element.getExperimentalElement(), -1); 7307 if (element.hasDateElement()) 7308 composeDateTime(t, "ImplementationGuide", "date", element.getDateElement(), -1); 7309 if (element.hasPublisherElement()) 7310 composeString(t, "ImplementationGuide", "publisher", element.getPublisherElement(), -1); 7311 for (int i = 0; i < element.getContact().size(); i++) 7312 composeContactDetail(t, "ImplementationGuide", "contact", element.getContact().get(i), i); 7313 if (element.hasDescriptionElement()) 7314 composeMarkdown(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 7315 for (int i = 0; i < element.getUseContext().size(); i++) 7316 composeUsageContext(t, "ImplementationGuide", "useContext", element.getUseContext().get(i), i); 7317 for (int i = 0; i < element.getJurisdiction().size(); i++) 7318 composeCodeableConcept(t, "ImplementationGuide", "jurisdiction", element.getJurisdiction().get(i), i); 7319 if (element.hasCopyrightElement()) 7320 composeMarkdown(t, "ImplementationGuide", "copyright", element.getCopyrightElement(), -1); 7321 if (element.hasFhirVersionElement()) 7322 composeId(t, "ImplementationGuide", "fhirVersion", element.getFhirVersionElement(), -1); 7323 for (int i = 0; i < element.getDependency().size(); i++) 7324 composeImplementationGuideImplementationGuideDependencyComponent(t, "ImplementationGuide", "dependency", element.getDependency().get(i), i); 7325 for (int i = 0; i < element.getPackage().size(); i++) 7326 composeImplementationGuideImplementationGuidePackageComponent(t, "ImplementationGuide", "package", element.getPackage().get(i), i); 7327 for (int i = 0; i < element.getGlobal().size(); i++) 7328 composeImplementationGuideImplementationGuideGlobalComponent(t, "ImplementationGuide", "global", element.getGlobal().get(i), i); 7329 for (int i = 0; i < element.getBinary().size(); i++) 7330 composeUri(t, "ImplementationGuide", "binary", element.getBinary().get(i), i); 7331 if (element.hasPage()) 7332 composeImplementationGuideImplementationGuidePageComponent(t, "ImplementationGuide", "page", element.getPage(), -1); 7333 } 7334 7335 protected void composeImplementationGuideImplementationGuideDependencyComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDependencyComponent element, int index) { 7336 if (element == null) 7337 return; 7338 Complex t; 7339 if (Utilities.noString(parentType)) 7340 t = parent; 7341 else { 7342 t = parent.predicate("fhir:"+parentType+'.'+name); 7343 } 7344 composeBackboneElement(t, "dependency", name, element, index); 7345 if (element.hasTypeElement()) 7346 composeEnum(t, "ImplementationGuide", "type", element.getTypeElement(), -1); 7347 if (element.hasUriElement()) 7348 composeUri(t, "ImplementationGuide", "uri", element.getUriElement(), -1); 7349 } 7350 7351 protected void composeImplementationGuideImplementationGuidePackageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePackageComponent element, int index) { 7352 if (element == null) 7353 return; 7354 Complex t; 7355 if (Utilities.noString(parentType)) 7356 t = parent; 7357 else { 7358 t = parent.predicate("fhir:"+parentType+'.'+name); 7359 } 7360 composeBackboneElement(t, "package", name, element, index); 7361 if (element.hasNameElement()) 7362 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 7363 if (element.hasDescriptionElement()) 7364 composeString(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 7365 for (int i = 0; i < element.getResource().size(); i++) 7366 composeImplementationGuideImplementationGuidePackageResourceComponent(t, "ImplementationGuide", "resource", element.getResource().get(i), i); 7367 } 7368 7369 protected void composeImplementationGuideImplementationGuidePackageResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePackageResourceComponent element, int index) { 7370 if (element == null) 7371 return; 7372 Complex t; 7373 if (Utilities.noString(parentType)) 7374 t = parent; 7375 else { 7376 t = parent.predicate("fhir:"+parentType+'.'+name); 7377 } 7378 composeBackboneElement(t, "resource", name, element, index); 7379 if (element.hasExampleElement()) 7380 composeBoolean(t, "ImplementationGuide", "example", element.getExampleElement(), -1); 7381 if (element.hasNameElement()) 7382 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 7383 if (element.hasDescriptionElement()) 7384 composeString(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 7385 if (element.hasAcronymElement()) 7386 composeString(t, "ImplementationGuide", "acronym", element.getAcronymElement(), -1); 7387 if (element.hasSource()) 7388 composeType(t, "ImplementationGuide", "source", element.getSource(), -1); 7389 if (element.hasExampleFor()) 7390 composeReference(t, "ImplementationGuide", "exampleFor", element.getExampleFor(), -1); 7391 } 7392 7393 protected void composeImplementationGuideImplementationGuideGlobalComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideGlobalComponent element, int index) { 7394 if (element == null) 7395 return; 7396 Complex t; 7397 if (Utilities.noString(parentType)) 7398 t = parent; 7399 else { 7400 t = parent.predicate("fhir:"+parentType+'.'+name); 7401 } 7402 composeBackboneElement(t, "global", name, element, index); 7403 if (element.hasTypeElement()) 7404 composeCode(t, "ImplementationGuide", "type", element.getTypeElement(), -1); 7405 if (element.hasProfile()) 7406 composeReference(t, "ImplementationGuide", "profile", element.getProfile(), -1); 7407 } 7408 7409 protected void composeImplementationGuideImplementationGuidePageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePageComponent element, int index) { 7410 if (element == null) 7411 return; 7412 Complex t; 7413 if (Utilities.noString(parentType)) 7414 t = parent; 7415 else { 7416 t = parent.predicate("fhir:"+parentType+'.'+name); 7417 } 7418 composeBackboneElement(t, "page", name, element, index); 7419 if (element.hasSourceElement()) 7420 composeUri(t, "ImplementationGuide", "source", element.getSourceElement(), -1); 7421 if (element.hasTitleElement()) 7422 composeString(t, "ImplementationGuide", "title", element.getTitleElement(), -1); 7423 if (element.hasKindElement()) 7424 composeEnum(t, "ImplementationGuide", "kind", element.getKindElement(), -1); 7425 for (int i = 0; i < element.getType().size(); i++) 7426 composeCode(t, "ImplementationGuide", "type", element.getType().get(i), i); 7427 for (int i = 0; i < element.getPackage().size(); i++) 7428 composeString(t, "ImplementationGuide", "package", element.getPackage().get(i), i); 7429 if (element.hasFormatElement()) 7430 composeCode(t, "ImplementationGuide", "format", element.getFormatElement(), -1); 7431 for (int i = 0; i < element.getPage().size(); i++) 7432 composeImplementationGuideImplementationGuidePageComponent(t, "ImplementationGuide", "page", element.getPage().get(i), i); 7433 } 7434 7435 protected void composeLibrary(Complex parent, String parentType, String name, Library 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:"+parentType+'.'+name); 7443 } 7444 composeDomainResource(t, "Library", name, element, index); 7445 if (element.hasUrlElement()) 7446 composeUri(t, "Library", "url", element.getUrlElement(), -1); 7447 for (int i = 0; i < element.getIdentifier().size(); i++) 7448 composeIdentifier(t, "Library", "identifier", element.getIdentifier().get(i), i); 7449 if (element.hasVersionElement()) 7450 composeString(t, "Library", "version", element.getVersionElement(), -1); 7451 if (element.hasNameElement()) 7452 composeString(t, "Library", "name", element.getNameElement(), -1); 7453 if (element.hasTitleElement()) 7454 composeString(t, "Library", "title", element.getTitleElement(), -1); 7455 if (element.hasStatusElement()) 7456 composeEnum(t, "Library", "status", element.getStatusElement(), -1); 7457 if (element.hasExperimentalElement()) 7458 composeBoolean(t, "Library", "experimental", element.getExperimentalElement(), -1); 7459 if (element.hasType()) 7460 composeCodeableConcept(t, "Library", "type", element.getType(), -1); 7461 if (element.hasDateElement()) 7462 composeDateTime(t, "Library", "date", element.getDateElement(), -1); 7463 if (element.hasPublisherElement()) 7464 composeString(t, "Library", "publisher", element.getPublisherElement(), -1); 7465 if (element.hasDescriptionElement()) 7466 composeMarkdown(t, "Library", "description", element.getDescriptionElement(), -1); 7467 if (element.hasPurposeElement()) 7468 composeMarkdown(t, "Library", "purpose", element.getPurposeElement(), -1); 7469 if (element.hasUsageElement()) 7470 composeString(t, "Library", "usage", element.getUsageElement(), -1); 7471 if (element.hasApprovalDateElement()) 7472 composeDate(t, "Library", "approvalDate", element.getApprovalDateElement(), -1); 7473 if (element.hasLastReviewDateElement()) 7474 composeDate(t, "Library", "lastReviewDate", element.getLastReviewDateElement(), -1); 7475 if (element.hasEffectivePeriod()) 7476 composePeriod(t, "Library", "effectivePeriod", element.getEffectivePeriod(), -1); 7477 for (int i = 0; i < element.getUseContext().size(); i++) 7478 composeUsageContext(t, "Library", "useContext", element.getUseContext().get(i), i); 7479 for (int i = 0; i < element.getJurisdiction().size(); i++) 7480 composeCodeableConcept(t, "Library", "jurisdiction", element.getJurisdiction().get(i), i); 7481 for (int i = 0; i < element.getTopic().size(); i++) 7482 composeCodeableConcept(t, "Library", "topic", element.getTopic().get(i), i); 7483 for (int i = 0; i < element.getContributor().size(); i++) 7484 composeContributor(t, "Library", "contributor", element.getContributor().get(i), i); 7485 for (int i = 0; i < element.getContact().size(); i++) 7486 composeContactDetail(t, "Library", "contact", element.getContact().get(i), i); 7487 if (element.hasCopyrightElement()) 7488 composeMarkdown(t, "Library", "copyright", element.getCopyrightElement(), -1); 7489 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 7490 composeRelatedArtifact(t, "Library", "relatedArtifact", element.getRelatedArtifact().get(i), i); 7491 for (int i = 0; i < element.getParameter().size(); i++) 7492 composeParameterDefinition(t, "Library", "parameter", element.getParameter().get(i), i); 7493 for (int i = 0; i < element.getDataRequirement().size(); i++) 7494 composeDataRequirement(t, "Library", "dataRequirement", element.getDataRequirement().get(i), i); 7495 for (int i = 0; i < element.getContent().size(); i++) 7496 composeAttachment(t, "Library", "content", element.getContent().get(i), i); 7497 } 7498 7499 protected void composeLinkage(Complex parent, String parentType, String name, Linkage element, int index) { 7500 if (element == null) 7501 return; 7502 Complex t; 7503 if (Utilities.noString(parentType)) 7504 t = parent; 7505 else { 7506 t = parent.predicate("fhir:"+parentType+'.'+name); 7507 } 7508 composeDomainResource(t, "Linkage", name, element, index); 7509 if (element.hasActiveElement()) 7510 composeBoolean(t, "Linkage", "active", element.getActiveElement(), -1); 7511 if (element.hasAuthor()) 7512 composeReference(t, "Linkage", "author", element.getAuthor(), -1); 7513 for (int i = 0; i < element.getItem().size(); i++) 7514 composeLinkageLinkageItemComponent(t, "Linkage", "item", element.getItem().get(i), i); 7515 } 7516 7517 protected void composeLinkageLinkageItemComponent(Complex parent, String parentType, String name, Linkage.LinkageItemComponent element, int index) { 7518 if (element == null) 7519 return; 7520 Complex t; 7521 if (Utilities.noString(parentType)) 7522 t = parent; 7523 else { 7524 t = parent.predicate("fhir:"+parentType+'.'+name); 7525 } 7526 composeBackboneElement(t, "item", name, element, index); 7527 if (element.hasTypeElement()) 7528 composeEnum(t, "Linkage", "type", element.getTypeElement(), -1); 7529 if (element.hasResource()) 7530 composeReference(t, "Linkage", "resource", element.getResource(), -1); 7531 } 7532 7533 protected void composeListResource(Complex parent, String parentType, String name, ListResource element, int index) { 7534 if (element == null) 7535 return; 7536 Complex t; 7537 if (Utilities.noString(parentType)) 7538 t = parent; 7539 else { 7540 t = parent.predicate("fhir:"+parentType+'.'+name); 7541 } 7542 composeDomainResource(t, "List", name, element, index); 7543 for (int i = 0; i < element.getIdentifier().size(); i++) 7544 composeIdentifier(t, "List", "identifier", element.getIdentifier().get(i), i); 7545 if (element.hasStatusElement()) 7546 composeEnum(t, "List", "status", element.getStatusElement(), -1); 7547 if (element.hasModeElement()) 7548 composeEnum(t, "List", "mode", element.getModeElement(), -1); 7549 if (element.hasTitleElement()) 7550 composeString(t, "List", "title", element.getTitleElement(), -1); 7551 if (element.hasCode()) 7552 composeCodeableConcept(t, "List", "code", element.getCode(), -1); 7553 if (element.hasSubject()) 7554 composeReference(t, "List", "subject", element.getSubject(), -1); 7555 if (element.hasEncounter()) 7556 composeReference(t, "List", "encounter", element.getEncounter(), -1); 7557 if (element.hasDateElement()) 7558 composeDateTime(t, "List", "date", element.getDateElement(), -1); 7559 if (element.hasSource()) 7560 composeReference(t, "List", "source", element.getSource(), -1); 7561 if (element.hasOrderedBy()) 7562 composeCodeableConcept(t, "List", "orderedBy", element.getOrderedBy(), -1); 7563 for (int i = 0; i < element.getNote().size(); i++) 7564 composeAnnotation(t, "List", "note", element.getNote().get(i), i); 7565 for (int i = 0; i < element.getEntry().size(); i++) 7566 composeListResourceListEntryComponent(t, "List", "entry", element.getEntry().get(i), i); 7567 if (element.hasEmptyReason()) 7568 composeCodeableConcept(t, "List", "emptyReason", element.getEmptyReason(), -1); 7569 } 7570 7571 protected void composeListResourceListEntryComponent(Complex parent, String parentType, String name, ListResource.ListEntryComponent element, int index) { 7572 if (element == null) 7573 return; 7574 Complex t; 7575 if (Utilities.noString(parentType)) 7576 t = parent; 7577 else { 7578 t = parent.predicate("fhir:"+parentType+'.'+name); 7579 } 7580 composeBackboneElement(t, "entry", name, element, index); 7581 if (element.hasFlag()) 7582 composeCodeableConcept(t, "List", "flag", element.getFlag(), -1); 7583 if (element.hasDeletedElement()) 7584 composeBoolean(t, "List", "deleted", element.getDeletedElement(), -1); 7585 if (element.hasDateElement()) 7586 composeDateTime(t, "List", "date", element.getDateElement(), -1); 7587 if (element.hasItem()) 7588 composeReference(t, "List", "item", element.getItem(), -1); 7589 } 7590 7591 protected void composeLocation(Complex parent, String parentType, String name, Location element, int index) { 7592 if (element == null) 7593 return; 7594 Complex t; 7595 if (Utilities.noString(parentType)) 7596 t = parent; 7597 else { 7598 t = parent.predicate("fhir:"+parentType+'.'+name); 7599 } 7600 composeDomainResource(t, "Location", name, element, index); 7601 for (int i = 0; i < element.getIdentifier().size(); i++) 7602 composeIdentifier(t, "Location", "identifier", element.getIdentifier().get(i), i); 7603 if (element.hasStatusElement()) 7604 composeEnum(t, "Location", "status", element.getStatusElement(), -1); 7605 if (element.hasOperationalStatus()) 7606 composeCoding(t, "Location", "operationalStatus", element.getOperationalStatus(), -1); 7607 if (element.hasNameElement()) 7608 composeString(t, "Location", "name", element.getNameElement(), -1); 7609 for (int i = 0; i < element.getAlias().size(); i++) 7610 composeString(t, "Location", "alias", element.getAlias().get(i), i); 7611 if (element.hasDescriptionElement()) 7612 composeString(t, "Location", "description", element.getDescriptionElement(), -1); 7613 if (element.hasModeElement()) 7614 composeEnum(t, "Location", "mode", element.getModeElement(), -1); 7615 if (element.hasType()) 7616 composeCodeableConcept(t, "Location", "type", element.getType(), -1); 7617 for (int i = 0; i < element.getTelecom().size(); i++) 7618 composeContactPoint(t, "Location", "telecom", element.getTelecom().get(i), i); 7619 if (element.hasAddress()) 7620 composeAddress(t, "Location", "address", element.getAddress(), -1); 7621 if (element.hasPhysicalType()) 7622 composeCodeableConcept(t, "Location", "physicalType", element.getPhysicalType(), -1); 7623 if (element.hasPosition()) 7624 composeLocationLocationPositionComponent(t, "Location", "position", element.getPosition(), -1); 7625 if (element.hasManagingOrganization()) 7626 composeReference(t, "Location", "managingOrganization", element.getManagingOrganization(), -1); 7627 if (element.hasPartOf()) 7628 composeReference(t, "Location", "partOf", element.getPartOf(), -1); 7629 for (int i = 0; i < element.getEndpoint().size(); i++) 7630 composeReference(t, "Location", "endpoint", element.getEndpoint().get(i), i); 7631 } 7632 7633 protected void composeLocationLocationPositionComponent(Complex parent, String parentType, String name, Location.LocationPositionComponent element, int index) { 7634 if (element == null) 7635 return; 7636 Complex t; 7637 if (Utilities.noString(parentType)) 7638 t = parent; 7639 else { 7640 t = parent.predicate("fhir:"+parentType+'.'+name); 7641 } 7642 composeBackboneElement(t, "position", name, element, index); 7643 if (element.hasLongitudeElement()) 7644 composeDecimal(t, "Location", "longitude", element.getLongitudeElement(), -1); 7645 if (element.hasLatitudeElement()) 7646 composeDecimal(t, "Location", "latitude", element.getLatitudeElement(), -1); 7647 if (element.hasAltitudeElement()) 7648 composeDecimal(t, "Location", "altitude", element.getAltitudeElement(), -1); 7649 } 7650 7651 protected void composeMeasure(Complex parent, String parentType, String name, Measure element, int index) { 7652 if (element == null) 7653 return; 7654 Complex t; 7655 if (Utilities.noString(parentType)) 7656 t = parent; 7657 else { 7658 t = parent.predicate("fhir:"+parentType+'.'+name); 7659 } 7660 composeDomainResource(t, "Measure", name, element, index); 7661 if (element.hasUrlElement()) 7662 composeUri(t, "Measure", "url", element.getUrlElement(), -1); 7663 for (int i = 0; i < element.getIdentifier().size(); i++) 7664 composeIdentifier(t, "Measure", "identifier", element.getIdentifier().get(i), i); 7665 if (element.hasVersionElement()) 7666 composeString(t, "Measure", "version", element.getVersionElement(), -1); 7667 if (element.hasNameElement()) 7668 composeString(t, "Measure", "name", element.getNameElement(), -1); 7669 if (element.hasTitleElement()) 7670 composeString(t, "Measure", "title", element.getTitleElement(), -1); 7671 if (element.hasStatusElement()) 7672 composeEnum(t, "Measure", "status", element.getStatusElement(), -1); 7673 if (element.hasExperimentalElement()) 7674 composeBoolean(t, "Measure", "experimental", element.getExperimentalElement(), -1); 7675 if (element.hasDateElement()) 7676 composeDateTime(t, "Measure", "date", element.getDateElement(), -1); 7677 if (element.hasPublisherElement()) 7678 composeString(t, "Measure", "publisher", element.getPublisherElement(), -1); 7679 if (element.hasDescriptionElement()) 7680 composeMarkdown(t, "Measure", "description", element.getDescriptionElement(), -1); 7681 if (element.hasPurposeElement()) 7682 composeMarkdown(t, "Measure", "purpose", element.getPurposeElement(), -1); 7683 if (element.hasUsageElement()) 7684 composeString(t, "Measure", "usage", element.getUsageElement(), -1); 7685 if (element.hasApprovalDateElement()) 7686 composeDate(t, "Measure", "approvalDate", element.getApprovalDateElement(), -1); 7687 if (element.hasLastReviewDateElement()) 7688 composeDate(t, "Measure", "lastReviewDate", element.getLastReviewDateElement(), -1); 7689 if (element.hasEffectivePeriod()) 7690 composePeriod(t, "Measure", "effectivePeriod", element.getEffectivePeriod(), -1); 7691 for (int i = 0; i < element.getUseContext().size(); i++) 7692 composeUsageContext(t, "Measure", "useContext", element.getUseContext().get(i), i); 7693 for (int i = 0; i < element.getJurisdiction().size(); i++) 7694 composeCodeableConcept(t, "Measure", "jurisdiction", element.getJurisdiction().get(i), i); 7695 for (int i = 0; i < element.getTopic().size(); i++) 7696 composeCodeableConcept(t, "Measure", "topic", element.getTopic().get(i), i); 7697 for (int i = 0; i < element.getContributor().size(); i++) 7698 composeContributor(t, "Measure", "contributor", element.getContributor().get(i), i); 7699 for (int i = 0; i < element.getContact().size(); i++) 7700 composeContactDetail(t, "Measure", "contact", element.getContact().get(i), i); 7701 if (element.hasCopyrightElement()) 7702 composeMarkdown(t, "Measure", "copyright", element.getCopyrightElement(), -1); 7703 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 7704 composeRelatedArtifact(t, "Measure", "relatedArtifact", element.getRelatedArtifact().get(i), i); 7705 for (int i = 0; i < element.getLibrary().size(); i++) 7706 composeReference(t, "Measure", "library", element.getLibrary().get(i), i); 7707 if (element.hasDisclaimerElement()) 7708 composeMarkdown(t, "Measure", "disclaimer", element.getDisclaimerElement(), -1); 7709 if (element.hasScoring()) 7710 composeCodeableConcept(t, "Measure", "scoring", element.getScoring(), -1); 7711 if (element.hasCompositeScoring()) 7712 composeCodeableConcept(t, "Measure", "compositeScoring", element.getCompositeScoring(), -1); 7713 for (int i = 0; i < element.getType().size(); i++) 7714 composeCodeableConcept(t, "Measure", "type", element.getType().get(i), i); 7715 if (element.hasRiskAdjustmentElement()) 7716 composeString(t, "Measure", "riskAdjustment", element.getRiskAdjustmentElement(), -1); 7717 if (element.hasRateAggregationElement()) 7718 composeString(t, "Measure", "rateAggregation", element.getRateAggregationElement(), -1); 7719 if (element.hasRationaleElement()) 7720 composeMarkdown(t, "Measure", "rationale", element.getRationaleElement(), -1); 7721 if (element.hasClinicalRecommendationStatementElement()) 7722 composeMarkdown(t, "Measure", "clinicalRecommendationStatement", element.getClinicalRecommendationStatementElement(), -1); 7723 if (element.hasImprovementNotationElement()) 7724 composeString(t, "Measure", "improvementNotation", element.getImprovementNotationElement(), -1); 7725 for (int i = 0; i < element.getDefinition().size(); i++) 7726 composeMarkdown(t, "Measure", "definition", element.getDefinition().get(i), i); 7727 if (element.hasGuidanceElement()) 7728 composeMarkdown(t, "Measure", "guidance", element.getGuidanceElement(), -1); 7729 if (element.hasSetElement()) 7730 composeString(t, "Measure", "set", element.getSetElement(), -1); 7731 for (int i = 0; i < element.getGroup().size(); i++) 7732 composeMeasureMeasureGroupComponent(t, "Measure", "group", element.getGroup().get(i), i); 7733 for (int i = 0; i < element.getSupplementalData().size(); i++) 7734 composeMeasureMeasureSupplementalDataComponent(t, "Measure", "supplementalData", element.getSupplementalData().get(i), i); 7735 } 7736 7737 protected void composeMeasureMeasureGroupComponent(Complex parent, String parentType, String name, Measure.MeasureGroupComponent element, int index) { 7738 if (element == null) 7739 return; 7740 Complex t; 7741 if (Utilities.noString(parentType)) 7742 t = parent; 7743 else { 7744 t = parent.predicate("fhir:"+parentType+'.'+name); 7745 } 7746 composeBackboneElement(t, "group", name, element, index); 7747 if (element.hasIdentifier()) 7748 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7749 if (element.hasNameElement()) 7750 composeString(t, "Measure", "name", element.getNameElement(), -1); 7751 if (element.hasDescriptionElement()) 7752 composeString(t, "Measure", "description", element.getDescriptionElement(), -1); 7753 for (int i = 0; i < element.getPopulation().size(); i++) 7754 composeMeasureMeasureGroupPopulationComponent(t, "Measure", "population", element.getPopulation().get(i), i); 7755 for (int i = 0; i < element.getStratifier().size(); i++) 7756 composeMeasureMeasureGroupStratifierComponent(t, "Measure", "stratifier", element.getStratifier().get(i), i); 7757 } 7758 7759 protected void composeMeasureMeasureGroupPopulationComponent(Complex parent, String parentType, String name, Measure.MeasureGroupPopulationComponent element, int index) { 7760 if (element == null) 7761 return; 7762 Complex t; 7763 if (Utilities.noString(parentType)) 7764 t = parent; 7765 else { 7766 t = parent.predicate("fhir:"+parentType+'.'+name); 7767 } 7768 composeBackboneElement(t, "population", name, element, index); 7769 if (element.hasIdentifier()) 7770 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7771 if (element.hasCode()) 7772 composeCodeableConcept(t, "Measure", "code", element.getCode(), -1); 7773 if (element.hasNameElement()) 7774 composeString(t, "Measure", "name", element.getNameElement(), -1); 7775 if (element.hasDescriptionElement()) 7776 composeString(t, "Measure", "description", element.getDescriptionElement(), -1); 7777 if (element.hasCriteriaElement()) 7778 composeString(t, "Measure", "criteria", element.getCriteriaElement(), -1); 7779 } 7780 7781 protected void composeMeasureMeasureGroupStratifierComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponent element, int index) { 7782 if (element == null) 7783 return; 7784 Complex t; 7785 if (Utilities.noString(parentType)) 7786 t = parent; 7787 else { 7788 t = parent.predicate("fhir:"+parentType+'.'+name); 7789 } 7790 composeBackboneElement(t, "stratifier", name, element, index); 7791 if (element.hasIdentifier()) 7792 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7793 if (element.hasCriteriaElement()) 7794 composeString(t, "Measure", "criteria", element.getCriteriaElement(), -1); 7795 if (element.hasPathElement()) 7796 composeString(t, "Measure", "path", element.getPathElement(), -1); 7797 } 7798 7799 protected void composeMeasureMeasureSupplementalDataComponent(Complex parent, String parentType, String name, Measure.MeasureSupplementalDataComponent element, int index) { 7800 if (element == null) 7801 return; 7802 Complex t; 7803 if (Utilities.noString(parentType)) 7804 t = parent; 7805 else { 7806 t = parent.predicate("fhir:"+parentType+'.'+name); 7807 } 7808 composeBackboneElement(t, "supplementalData", name, element, index); 7809 if (element.hasIdentifier()) 7810 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7811 for (int i = 0; i < element.getUsage().size(); i++) 7812 composeCodeableConcept(t, "Measure", "usage", element.getUsage().get(i), i); 7813 if (element.hasCriteriaElement()) 7814 composeString(t, "Measure", "criteria", element.getCriteriaElement(), -1); 7815 if (element.hasPathElement()) 7816 composeString(t, "Measure", "path", element.getPathElement(), -1); 7817 } 7818 7819 protected void composeMeasureReport(Complex parent, String parentType, String name, MeasureReport element, int index) { 7820 if (element == null) 7821 return; 7822 Complex t; 7823 if (Utilities.noString(parentType)) 7824 t = parent; 7825 else { 7826 t = parent.predicate("fhir:"+parentType+'.'+name); 7827 } 7828 composeDomainResource(t, "MeasureReport", name, element, index); 7829 if (element.hasIdentifier()) 7830 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7831 if (element.hasStatusElement()) 7832 composeEnum(t, "MeasureReport", "status", element.getStatusElement(), -1); 7833 if (element.hasTypeElement()) 7834 composeEnum(t, "MeasureReport", "type", element.getTypeElement(), -1); 7835 if (element.hasMeasure()) 7836 composeReference(t, "MeasureReport", "measure", element.getMeasure(), -1); 7837 if (element.hasPatient()) 7838 composeReference(t, "MeasureReport", "patient", element.getPatient(), -1); 7839 if (element.hasDateElement()) 7840 composeDateTime(t, "MeasureReport", "date", element.getDateElement(), -1); 7841 if (element.hasReportingOrganization()) 7842 composeReference(t, "MeasureReport", "reportingOrganization", element.getReportingOrganization(), -1); 7843 if (element.hasPeriod()) 7844 composePeriod(t, "MeasureReport", "period", element.getPeriod(), -1); 7845 for (int i = 0; i < element.getGroup().size(); i++) 7846 composeMeasureReportMeasureReportGroupComponent(t, "MeasureReport", "group", element.getGroup().get(i), i); 7847 if (element.hasEvaluatedResources()) 7848 composeReference(t, "MeasureReport", "evaluatedResources", element.getEvaluatedResources(), -1); 7849 } 7850 7851 protected void composeMeasureReportMeasureReportGroupComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupComponent element, int index) { 7852 if (element == null) 7853 return; 7854 Complex t; 7855 if (Utilities.noString(parentType)) 7856 t = parent; 7857 else { 7858 t = parent.predicate("fhir:"+parentType+'.'+name); 7859 } 7860 composeBackboneElement(t, "group", name, element, index); 7861 if (element.hasIdentifier()) 7862 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7863 for (int i = 0; i < element.getPopulation().size(); i++) 7864 composeMeasureReportMeasureReportGroupPopulationComponent(t, "MeasureReport", "population", element.getPopulation().get(i), i); 7865 if (element.hasMeasureScoreElement()) 7866 composeDecimal(t, "MeasureReport", "measureScore", element.getMeasureScoreElement(), -1); 7867 for (int i = 0; i < element.getStratifier().size(); i++) 7868 composeMeasureReportMeasureReportGroupStratifierComponent(t, "MeasureReport", "stratifier", element.getStratifier().get(i), i); 7869 } 7870 7871 protected void composeMeasureReportMeasureReportGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupPopulationComponent element, int index) { 7872 if (element == null) 7873 return; 7874 Complex t; 7875 if (Utilities.noString(parentType)) 7876 t = parent; 7877 else { 7878 t = parent.predicate("fhir:"+parentType+'.'+name); 7879 } 7880 composeBackboneElement(t, "population", name, element, index); 7881 if (element.hasIdentifier()) 7882 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7883 if (element.hasCode()) 7884 composeCodeableConcept(t, "MeasureReport", "code", element.getCode(), -1); 7885 if (element.hasCountElement()) 7886 composeInteger(t, "MeasureReport", "count", element.getCountElement(), -1); 7887 if (element.hasPatients()) 7888 composeReference(t, "MeasureReport", "patients", element.getPatients(), -1); 7889 } 7890 7891 protected void composeMeasureReportMeasureReportGroupStratifierComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupStratifierComponent element, int index) { 7892 if (element == null) 7893 return; 7894 Complex t; 7895 if (Utilities.noString(parentType)) 7896 t = parent; 7897 else { 7898 t = parent.predicate("fhir:"+parentType+'.'+name); 7899 } 7900 composeBackboneElement(t, "stratifier", name, element, index); 7901 if (element.hasIdentifier()) 7902 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7903 for (int i = 0; i < element.getStratum().size(); i++) 7904 composeMeasureReportStratifierGroupComponent(t, "MeasureReport", "stratum", element.getStratum().get(i), i); 7905 } 7906 7907 protected void composeMeasureReportStratifierGroupComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupComponent element, int index) { 7908 if (element == null) 7909 return; 7910 Complex t; 7911 if (Utilities.noString(parentType)) 7912 t = parent; 7913 else { 7914 t = parent.predicate("fhir:"+parentType+'.'+name); 7915 } 7916 composeBackboneElement(t, "stratum", name, element, index); 7917 if (element.hasValueElement()) 7918 composeString(t, "MeasureReport", "value", element.getValueElement(), -1); 7919 for (int i = 0; i < element.getPopulation().size(); i++) 7920 composeMeasureReportStratifierGroupPopulationComponent(t, "MeasureReport", "population", element.getPopulation().get(i), i); 7921 if (element.hasMeasureScoreElement()) 7922 composeDecimal(t, "MeasureReport", "measureScore", element.getMeasureScoreElement(), -1); 7923 } 7924 7925 protected void composeMeasureReportStratifierGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupPopulationComponent element, int index) { 7926 if (element == null) 7927 return; 7928 Complex t; 7929 if (Utilities.noString(parentType)) 7930 t = parent; 7931 else { 7932 t = parent.predicate("fhir:"+parentType+'.'+name); 7933 } 7934 composeBackboneElement(t, "population", name, element, index); 7935 if (element.hasIdentifier()) 7936 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7937 if (element.hasCode()) 7938 composeCodeableConcept(t, "MeasureReport", "code", element.getCode(), -1); 7939 if (element.hasCountElement()) 7940 composeInteger(t, "MeasureReport", "count", element.getCountElement(), -1); 7941 if (element.hasPatients()) 7942 composeReference(t, "MeasureReport", "patients", element.getPatients(), -1); 7943 } 7944 7945 protected void composeMedia(Complex parent, String parentType, String name, Media element, int index) { 7946 if (element == null) 7947 return; 7948 Complex t; 7949 if (Utilities.noString(parentType)) 7950 t = parent; 7951 else { 7952 t = parent.predicate("fhir:"+parentType+'.'+name); 7953 } 7954 composeDomainResource(t, "Media", name, element, index); 7955 for (int i = 0; i < element.getIdentifier().size(); i++) 7956 composeIdentifier(t, "Media", "identifier", element.getIdentifier().get(i), i); 7957 for (int i = 0; i < element.getBasedOn().size(); i++) 7958 composeReference(t, "Media", "basedOn", element.getBasedOn().get(i), i); 7959 if (element.hasTypeElement()) 7960 composeEnum(t, "Media", "type", element.getTypeElement(), -1); 7961 if (element.hasSubtype()) 7962 composeCodeableConcept(t, "Media", "subtype", element.getSubtype(), -1); 7963 if (element.hasView()) 7964 composeCodeableConcept(t, "Media", "view", element.getView(), -1); 7965 if (element.hasSubject()) 7966 composeReference(t, "Media", "subject", element.getSubject(), -1); 7967 if (element.hasContext()) 7968 composeReference(t, "Media", "context", element.getContext(), -1); 7969 if (element.hasOccurrence()) 7970 composeType(t, "Media", "occurrence", element.getOccurrence(), -1); 7971 if (element.hasOperator()) 7972 composeReference(t, "Media", "operator", element.getOperator(), -1); 7973 for (int i = 0; i < element.getReasonCode().size(); i++) 7974 composeCodeableConcept(t, "Media", "reasonCode", element.getReasonCode().get(i), i); 7975 if (element.hasBodySite()) 7976 composeCodeableConcept(t, "Media", "bodySite", element.getBodySite(), -1); 7977 if (element.hasDevice()) 7978 composeReference(t, "Media", "device", element.getDevice(), -1); 7979 if (element.hasHeightElement()) 7980 composePositiveInt(t, "Media", "height", element.getHeightElement(), -1); 7981 if (element.hasWidthElement()) 7982 composePositiveInt(t, "Media", "width", element.getWidthElement(), -1); 7983 if (element.hasFramesElement()) 7984 composePositiveInt(t, "Media", "frames", element.getFramesElement(), -1); 7985 if (element.hasDurationElement()) 7986 composeUnsignedInt(t, "Media", "duration", element.getDurationElement(), -1); 7987 if (element.hasContent()) 7988 composeAttachment(t, "Media", "content", element.getContent(), -1); 7989 for (int i = 0; i < element.getNote().size(); i++) 7990 composeAnnotation(t, "Media", "note", element.getNote().get(i), i); 7991 } 7992 7993 protected void composeMedication(Complex parent, String parentType, String name, Medication element, int index) { 7994 if (element == null) 7995 return; 7996 Complex t; 7997 if (Utilities.noString(parentType)) 7998 t = parent; 7999 else { 8000 t = parent.predicate("fhir:"+parentType+'.'+name); 8001 } 8002 composeDomainResource(t, "Medication", name, element, index); 8003 if (element.hasCode()) 8004 composeCodeableConcept(t, "Medication", "code", element.getCode(), -1); 8005 if (element.hasStatusElement()) 8006 composeEnum(t, "Medication", "status", element.getStatusElement(), -1); 8007 if (element.hasIsBrandElement()) 8008 composeBoolean(t, "Medication", "isBrand", element.getIsBrandElement(), -1); 8009 if (element.hasIsOverTheCounterElement()) 8010 composeBoolean(t, "Medication", "isOverTheCounter", element.getIsOverTheCounterElement(), -1); 8011 if (element.hasManufacturer()) 8012 composeReference(t, "Medication", "manufacturer", element.getManufacturer(), -1); 8013 if (element.hasForm()) 8014 composeCodeableConcept(t, "Medication", "form", element.getForm(), -1); 8015 for (int i = 0; i < element.getIngredient().size(); i++) 8016 composeMedicationMedicationIngredientComponent(t, "Medication", "ingredient", element.getIngredient().get(i), i); 8017 if (element.hasPackage()) 8018 composeMedicationMedicationPackageComponent(t, "Medication", "package", element.getPackage(), -1); 8019 for (int i = 0; i < element.getImage().size(); i++) 8020 composeAttachment(t, "Medication", "image", element.getImage().get(i), i); 8021 } 8022 8023 protected void composeMedicationMedicationIngredientComponent(Complex parent, String parentType, String name, Medication.MedicationIngredientComponent element, int index) { 8024 if (element == null) 8025 return; 8026 Complex t; 8027 if (Utilities.noString(parentType)) 8028 t = parent; 8029 else { 8030 t = parent.predicate("fhir:"+parentType+'.'+name); 8031 } 8032 composeBackboneElement(t, "ingredient", name, element, index); 8033 if (element.hasItem()) 8034 composeType(t, "Medication", "item", element.getItem(), -1); 8035 if (element.hasIsActiveElement()) 8036 composeBoolean(t, "Medication", "isActive", element.getIsActiveElement(), -1); 8037 if (element.hasAmount()) 8038 composeRatio(t, "Medication", "amount", element.getAmount(), -1); 8039 } 8040 8041 protected void composeMedicationMedicationPackageComponent(Complex parent, String parentType, String name, Medication.MedicationPackageComponent 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:"+parentType+'.'+name); 8049 } 8050 composeBackboneElement(t, "package", name, element, index); 8051 if (element.hasContainer()) 8052 composeCodeableConcept(t, "Medication", "container", element.getContainer(), -1); 8053 for (int i = 0; i < element.getContent().size(); i++) 8054 composeMedicationMedicationPackageContentComponent(t, "Medication", "content", element.getContent().get(i), i); 8055 for (int i = 0; i < element.getBatch().size(); i++) 8056 composeMedicationMedicationPackageBatchComponent(t, "Medication", "batch", element.getBatch().get(i), i); 8057 } 8058 8059 protected void composeMedicationMedicationPackageContentComponent(Complex parent, String parentType, String name, Medication.MedicationPackageContentComponent 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:"+parentType+'.'+name); 8067 } 8068 composeBackboneElement(t, "content", name, element, index); 8069 if (element.hasItem()) 8070 composeType(t, "Medication", "item", element.getItem(), -1); 8071 if (element.hasAmount()) 8072 composeQuantity(t, "Medication", "amount", element.getAmount(), -1); 8073 } 8074 8075 protected void composeMedicationMedicationPackageBatchComponent(Complex parent, String parentType, String name, Medication.MedicationPackageBatchComponent element, int index) { 8076 if (element == null) 8077 return; 8078 Complex t; 8079 if (Utilities.noString(parentType)) 8080 t = parent; 8081 else { 8082 t = parent.predicate("fhir:"+parentType+'.'+name); 8083 } 8084 composeBackboneElement(t, "batch", name, element, index); 8085 if (element.hasLotNumberElement()) 8086 composeString(t, "Medication", "lotNumber", element.getLotNumberElement(), -1); 8087 if (element.hasExpirationDateElement()) 8088 composeDateTime(t, "Medication", "expirationDate", element.getExpirationDateElement(), -1); 8089 } 8090 8091 protected void composeMedicationAdministration(Complex parent, String parentType, String name, MedicationAdministration element, int index) { 8092 if (element == null) 8093 return; 8094 Complex t; 8095 if (Utilities.noString(parentType)) 8096 t = parent; 8097 else { 8098 t = parent.predicate("fhir:"+parentType+'.'+name); 8099 } 8100 composeDomainResource(t, "MedicationAdministration", name, element, index); 8101 for (int i = 0; i < element.getIdentifier().size(); i++) 8102 composeIdentifier(t, "MedicationAdministration", "identifier", element.getIdentifier().get(i), i); 8103 for (int i = 0; i < element.getDefinition().size(); i++) 8104 composeReference(t, "MedicationAdministration", "definition", element.getDefinition().get(i), i); 8105 for (int i = 0; i < element.getPartOf().size(); i++) 8106 composeReference(t, "MedicationAdministration", "partOf", element.getPartOf().get(i), i); 8107 if (element.hasStatusElement()) 8108 composeEnum(t, "MedicationAdministration", "status", element.getStatusElement(), -1); 8109 if (element.hasCategory()) 8110 composeCodeableConcept(t, "MedicationAdministration", "category", element.getCategory(), -1); 8111 if (element.hasMedication()) 8112 composeType(t, "MedicationAdministration", "medication", element.getMedication(), -1); 8113 if (element.hasSubject()) 8114 composeReference(t, "MedicationAdministration", "subject", element.getSubject(), -1); 8115 if (element.hasContext()) 8116 composeReference(t, "MedicationAdministration", "context", element.getContext(), -1); 8117 for (int i = 0; i < element.getSupportingInformation().size(); i++) 8118 composeReference(t, "MedicationAdministration", "supportingInformation", element.getSupportingInformation().get(i), i); 8119 if (element.hasEffective()) 8120 composeType(t, "MedicationAdministration", "effective", element.getEffective(), -1); 8121 for (int i = 0; i < element.getPerformer().size(); i++) 8122 composeMedicationAdministrationMedicationAdministrationPerformerComponent(t, "MedicationAdministration", "performer", element.getPerformer().get(i), i); 8123 if (element.hasNotGivenElement()) 8124 composeBoolean(t, "MedicationAdministration", "notGiven", element.getNotGivenElement(), -1); 8125 for (int i = 0; i < element.getReasonNotGiven().size(); i++) 8126 composeCodeableConcept(t, "MedicationAdministration", "reasonNotGiven", element.getReasonNotGiven().get(i), i); 8127 for (int i = 0; i < element.getReasonCode().size(); i++) 8128 composeCodeableConcept(t, "MedicationAdministration", "reasonCode", element.getReasonCode().get(i), i); 8129 for (int i = 0; i < element.getReasonReference().size(); i++) 8130 composeReference(t, "MedicationAdministration", "reasonReference", element.getReasonReference().get(i), i); 8131 if (element.hasPrescription()) 8132 composeReference(t, "MedicationAdministration", "prescription", element.getPrescription(), -1); 8133 for (int i = 0; i < element.getDevice().size(); i++) 8134 composeReference(t, "MedicationAdministration", "device", element.getDevice().get(i), i); 8135 for (int i = 0; i < element.getNote().size(); i++) 8136 composeAnnotation(t, "MedicationAdministration", "note", element.getNote().get(i), i); 8137 if (element.hasDosage()) 8138 composeMedicationAdministrationMedicationAdministrationDosageComponent(t, "MedicationAdministration", "dosage", element.getDosage(), -1); 8139 for (int i = 0; i < element.getEventHistory().size(); i++) 8140 composeReference(t, "MedicationAdministration", "eventHistory", element.getEventHistory().get(i), i); 8141 } 8142 8143 protected void composeMedicationAdministrationMedicationAdministrationPerformerComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationPerformerComponent element, int index) { 8144 if (element == null) 8145 return; 8146 Complex t; 8147 if (Utilities.noString(parentType)) 8148 t = parent; 8149 else { 8150 t = parent.predicate("fhir:"+parentType+'.'+name); 8151 } 8152 composeBackboneElement(t, "performer", name, element, index); 8153 if (element.hasActor()) 8154 composeReference(t, "MedicationAdministration", "actor", element.getActor(), -1); 8155 if (element.hasOnBehalfOf()) 8156 composeReference(t, "MedicationAdministration", "onBehalfOf", element.getOnBehalfOf(), -1); 8157 } 8158 8159 protected void composeMedicationAdministrationMedicationAdministrationDosageComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationDosageComponent element, int index) { 8160 if (element == null) 8161 return; 8162 Complex t; 8163 if (Utilities.noString(parentType)) 8164 t = parent; 8165 else { 8166 t = parent.predicate("fhir:"+parentType+'.'+name); 8167 } 8168 composeBackboneElement(t, "dosage", name, element, index); 8169 if (element.hasTextElement()) 8170 composeString(t, "MedicationAdministration", "text", element.getTextElement(), -1); 8171 if (element.hasSite()) 8172 composeCodeableConcept(t, "MedicationAdministration", "site", element.getSite(), -1); 8173 if (element.hasRoute()) 8174 composeCodeableConcept(t, "MedicationAdministration", "route", element.getRoute(), -1); 8175 if (element.hasMethod()) 8176 composeCodeableConcept(t, "MedicationAdministration", "method", element.getMethod(), -1); 8177 if (element.hasDose()) 8178 composeQuantity(t, "MedicationAdministration", "dose", element.getDose(), -1); 8179 if (element.hasRate()) 8180 composeType(t, "MedicationAdministration", "rate", element.getRate(), -1); 8181 } 8182 8183 protected void composeMedicationDispense(Complex parent, String parentType, String name, MedicationDispense element, int index) { 8184 if (element == null) 8185 return; 8186 Complex t; 8187 if (Utilities.noString(parentType)) 8188 t = parent; 8189 else { 8190 t = parent.predicate("fhir:"+parentType+'.'+name); 8191 } 8192 composeDomainResource(t, "MedicationDispense", name, element, index); 8193 for (int i = 0; i < element.getIdentifier().size(); i++) 8194 composeIdentifier(t, "MedicationDispense", "identifier", element.getIdentifier().get(i), i); 8195 for (int i = 0; i < element.getPartOf().size(); i++) 8196 composeReference(t, "MedicationDispense", "partOf", element.getPartOf().get(i), i); 8197 if (element.hasStatusElement()) 8198 composeEnum(t, "MedicationDispense", "status", element.getStatusElement(), -1); 8199 if (element.hasCategory()) 8200 composeCodeableConcept(t, "MedicationDispense", "category", element.getCategory(), -1); 8201 if (element.hasMedication()) 8202 composeType(t, "MedicationDispense", "medication", element.getMedication(), -1); 8203 if (element.hasSubject()) 8204 composeReference(t, "MedicationDispense", "subject", element.getSubject(), -1); 8205 if (element.hasContext()) 8206 composeReference(t, "MedicationDispense", "context", element.getContext(), -1); 8207 for (int i = 0; i < element.getSupportingInformation().size(); i++) 8208 composeReference(t, "MedicationDispense", "supportingInformation", element.getSupportingInformation().get(i), i); 8209 for (int i = 0; i < element.getPerformer().size(); i++) 8210 composeMedicationDispenseMedicationDispensePerformerComponent(t, "MedicationDispense", "performer", element.getPerformer().get(i), i); 8211 for (int i = 0; i < element.getAuthorizingPrescription().size(); i++) 8212 composeReference(t, "MedicationDispense", "authorizingPrescription", element.getAuthorizingPrescription().get(i), i); 8213 if (element.hasType()) 8214 composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1); 8215 if (element.hasQuantity()) 8216 composeQuantity(t, "MedicationDispense", "quantity", element.getQuantity(), -1); 8217 if (element.hasDaysSupply()) 8218 composeQuantity(t, "MedicationDispense", "daysSupply", element.getDaysSupply(), -1); 8219 if (element.hasWhenPreparedElement()) 8220 composeDateTime(t, "MedicationDispense", "whenPrepared", element.getWhenPreparedElement(), -1); 8221 if (element.hasWhenHandedOverElement()) 8222 composeDateTime(t, "MedicationDispense", "whenHandedOver", element.getWhenHandedOverElement(), -1); 8223 if (element.hasDestination()) 8224 composeReference(t, "MedicationDispense", "destination", element.getDestination(), -1); 8225 for (int i = 0; i < element.getReceiver().size(); i++) 8226 composeReference(t, "MedicationDispense", "receiver", element.getReceiver().get(i), i); 8227 for (int i = 0; i < element.getNote().size(); i++) 8228 composeAnnotation(t, "MedicationDispense", "note", element.getNote().get(i), i); 8229 for (int i = 0; i < element.getDosageInstruction().size(); i++) 8230 composeDosage(t, "MedicationDispense", "dosageInstruction", element.getDosageInstruction().get(i), i); 8231 if (element.hasSubstitution()) 8232 composeMedicationDispenseMedicationDispenseSubstitutionComponent(t, "MedicationDispense", "substitution", element.getSubstitution(), -1); 8233 for (int i = 0; i < element.getDetectedIssue().size(); i++) 8234 composeReference(t, "MedicationDispense", "detectedIssue", element.getDetectedIssue().get(i), i); 8235 if (element.hasNotDoneElement()) 8236 composeBoolean(t, "MedicationDispense", "notDone", element.getNotDoneElement(), -1); 8237 if (element.hasNotDoneReason()) 8238 composeType(t, "MedicationDispense", "notDoneReason", element.getNotDoneReason(), -1); 8239 for (int i = 0; i < element.getEventHistory().size(); i++) 8240 composeReference(t, "MedicationDispense", "eventHistory", element.getEventHistory().get(i), i); 8241 } 8242 8243 protected void composeMedicationDispenseMedicationDispensePerformerComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispensePerformerComponent element, int index) { 8244 if (element == null) 8245 return; 8246 Complex t; 8247 if (Utilities.noString(parentType)) 8248 t = parent; 8249 else { 8250 t = parent.predicate("fhir:"+parentType+'.'+name); 8251 } 8252 composeBackboneElement(t, "performer", name, element, index); 8253 if (element.hasActor()) 8254 composeReference(t, "MedicationDispense", "actor", element.getActor(), -1); 8255 if (element.hasOnBehalfOf()) 8256 composeReference(t, "MedicationDispense", "onBehalfOf", element.getOnBehalfOf(), -1); 8257 } 8258 8259 protected void composeMedicationDispenseMedicationDispenseSubstitutionComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispenseSubstitutionComponent element, int index) { 8260 if (element == null) 8261 return; 8262 Complex t; 8263 if (Utilities.noString(parentType)) 8264 t = parent; 8265 else { 8266 t = parent.predicate("fhir:"+parentType+'.'+name); 8267 } 8268 composeBackboneElement(t, "substitution", name, element, index); 8269 if (element.hasWasSubstitutedElement()) 8270 composeBoolean(t, "MedicationDispense", "wasSubstituted", element.getWasSubstitutedElement(), -1); 8271 if (element.hasType()) 8272 composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1); 8273 for (int i = 0; i < element.getReason().size(); i++) 8274 composeCodeableConcept(t, "MedicationDispense", "reason", element.getReason().get(i), i); 8275 for (int i = 0; i < element.getResponsibleParty().size(); i++) 8276 composeReference(t, "MedicationDispense", "responsibleParty", element.getResponsibleParty().get(i), i); 8277 } 8278 8279 protected void composeMedicationRequest(Complex parent, String parentType, String name, MedicationRequest element, int index) { 8280 if (element == null) 8281 return; 8282 Complex t; 8283 if (Utilities.noString(parentType)) 8284 t = parent; 8285 else { 8286 t = parent.predicate("fhir:"+parentType+'.'+name); 8287 } 8288 composeDomainResource(t, "MedicationRequest", name, element, index); 8289 for (int i = 0; i < element.getIdentifier().size(); i++) 8290 composeIdentifier(t, "MedicationRequest", "identifier", element.getIdentifier().get(i), i); 8291 for (int i = 0; i < element.getDefinition().size(); i++) 8292 composeReference(t, "MedicationRequest", "definition", element.getDefinition().get(i), i); 8293 for (int i = 0; i < element.getBasedOn().size(); i++) 8294 composeReference(t, "MedicationRequest", "basedOn", element.getBasedOn().get(i), i); 8295 if (element.hasGroupIdentifier()) 8296 composeIdentifier(t, "MedicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 8297 if (element.hasStatusElement()) 8298 composeEnum(t, "MedicationRequest", "status", element.getStatusElement(), -1); 8299 if (element.hasIntentElement()) 8300 composeEnum(t, "MedicationRequest", "intent", element.getIntentElement(), -1); 8301 if (element.hasCategory()) 8302 composeCodeableConcept(t, "MedicationRequest", "category", element.getCategory(), -1); 8303 if (element.hasPriorityElement()) 8304 composeEnum(t, "MedicationRequest", "priority", element.getPriorityElement(), -1); 8305 if (element.hasMedication()) 8306 composeType(t, "MedicationRequest", "medication", element.getMedication(), -1); 8307 if (element.hasSubject()) 8308 composeReference(t, "MedicationRequest", "subject", element.getSubject(), -1); 8309 if (element.hasContext()) 8310 composeReference(t, "MedicationRequest", "context", element.getContext(), -1); 8311 for (int i = 0; i < element.getSupportingInformation().size(); i++) 8312 composeReference(t, "MedicationRequest", "supportingInformation", element.getSupportingInformation().get(i), i); 8313 if (element.hasAuthoredOnElement()) 8314 composeDateTime(t, "MedicationRequest", "authoredOn", element.getAuthoredOnElement(), -1); 8315 if (element.hasRequester()) 8316 composeMedicationRequestMedicationRequestRequesterComponent(t, "MedicationRequest", "requester", element.getRequester(), -1); 8317 if (element.hasRecorder()) 8318 composeReference(t, "MedicationRequest", "recorder", element.getRecorder(), -1); 8319 for (int i = 0; i < element.getReasonCode().size(); i++) 8320 composeCodeableConcept(t, "MedicationRequest", "reasonCode", element.getReasonCode().get(i), i); 8321 for (int i = 0; i < element.getReasonReference().size(); i++) 8322 composeReference(t, "MedicationRequest", "reasonReference", element.getReasonReference().get(i), i); 8323 for (int i = 0; i < element.getNote().size(); i++) 8324 composeAnnotation(t, "MedicationRequest", "note", element.getNote().get(i), i); 8325 for (int i = 0; i < element.getDosageInstruction().size(); i++) 8326 composeDosage(t, "MedicationRequest", "dosageInstruction", element.getDosageInstruction().get(i), i); 8327 if (element.hasDispenseRequest()) 8328 composeMedicationRequestMedicationRequestDispenseRequestComponent(t, "MedicationRequest", "dispenseRequest", element.getDispenseRequest(), -1); 8329 if (element.hasSubstitution()) 8330 composeMedicationRequestMedicationRequestSubstitutionComponent(t, "MedicationRequest", "substitution", element.getSubstitution(), -1); 8331 if (element.hasPriorPrescription()) 8332 composeReference(t, "MedicationRequest", "priorPrescription", element.getPriorPrescription(), -1); 8333 for (int i = 0; i < element.getDetectedIssue().size(); i++) 8334 composeReference(t, "MedicationRequest", "detectedIssue", element.getDetectedIssue().get(i), i); 8335 for (int i = 0; i < element.getEventHistory().size(); i++) 8336 composeReference(t, "MedicationRequest", "eventHistory", element.getEventHistory().get(i), i); 8337 } 8338 8339 protected void composeMedicationRequestMedicationRequestRequesterComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestRequesterComponent element, int index) { 8340 if (element == null) 8341 return; 8342 Complex t; 8343 if (Utilities.noString(parentType)) 8344 t = parent; 8345 else { 8346 t = parent.predicate("fhir:"+parentType+'.'+name); 8347 } 8348 composeBackboneElement(t, "requester", name, element, index); 8349 if (element.hasAgent()) 8350 composeReference(t, "MedicationRequest", "agent", element.getAgent(), -1); 8351 if (element.hasOnBehalfOf()) 8352 composeReference(t, "MedicationRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 8353 } 8354 8355 protected void composeMedicationRequestMedicationRequestDispenseRequestComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestDispenseRequestComponent element, int index) { 8356 if (element == null) 8357 return; 8358 Complex t; 8359 if (Utilities.noString(parentType)) 8360 t = parent; 8361 else { 8362 t = parent.predicate("fhir:"+parentType+'.'+name); 8363 } 8364 composeBackboneElement(t, "dispenseRequest", name, element, index); 8365 if (element.hasValidityPeriod()) 8366 composePeriod(t, "MedicationRequest", "validityPeriod", element.getValidityPeriod(), -1); 8367 if (element.hasNumberOfRepeatsAllowedElement()) 8368 composePositiveInt(t, "MedicationRequest", "numberOfRepeatsAllowed", element.getNumberOfRepeatsAllowedElement(), -1); 8369 if (element.hasQuantity()) 8370 composeQuantity(t, "MedicationRequest", "quantity", element.getQuantity(), -1); 8371 if (element.hasExpectedSupplyDuration()) 8372 composeDuration(t, "MedicationRequest", "expectedSupplyDuration", element.getExpectedSupplyDuration(), -1); 8373 if (element.hasPerformer()) 8374 composeReference(t, "MedicationRequest", "performer", element.getPerformer(), -1); 8375 } 8376 8377 protected void composeMedicationRequestMedicationRequestSubstitutionComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestSubstitutionComponent element, int index) { 8378 if (element == null) 8379 return; 8380 Complex t; 8381 if (Utilities.noString(parentType)) 8382 t = parent; 8383 else { 8384 t = parent.predicate("fhir:"+parentType+'.'+name); 8385 } 8386 composeBackboneElement(t, "substitution", name, element, index); 8387 if (element.hasAllowedElement()) 8388 composeBoolean(t, "MedicationRequest", "allowed", element.getAllowedElement(), -1); 8389 if (element.hasReason()) 8390 composeCodeableConcept(t, "MedicationRequest", "reason", element.getReason(), -1); 8391 } 8392 8393 protected void composeMedicationStatement(Complex parent, String parentType, String name, MedicationStatement element, int index) { 8394 if (element == null) 8395 return; 8396 Complex t; 8397 if (Utilities.noString(parentType)) 8398 t = parent; 8399 else { 8400 t = parent.predicate("fhir:"+parentType+'.'+name); 8401 } 8402 composeDomainResource(t, "MedicationStatement", name, element, index); 8403 for (int i = 0; i < element.getIdentifier().size(); i++) 8404 composeIdentifier(t, "MedicationStatement", "identifier", element.getIdentifier().get(i), i); 8405 for (int i = 0; i < element.getBasedOn().size(); i++) 8406 composeReference(t, "MedicationStatement", "basedOn", element.getBasedOn().get(i), i); 8407 for (int i = 0; i < element.getPartOf().size(); i++) 8408 composeReference(t, "MedicationStatement", "partOf", element.getPartOf().get(i), i); 8409 if (element.hasContext()) 8410 composeReference(t, "MedicationStatement", "context", element.getContext(), -1); 8411 if (element.hasStatusElement()) 8412 composeEnum(t, "MedicationStatement", "status", element.getStatusElement(), -1); 8413 if (element.hasCategory()) 8414 composeCodeableConcept(t, "MedicationStatement", "category", element.getCategory(), -1); 8415 if (element.hasMedication()) 8416 composeType(t, "MedicationStatement", "medication", element.getMedication(), -1); 8417 if (element.hasEffective()) 8418 composeType(t, "MedicationStatement", "effective", element.getEffective(), -1); 8419 if (element.hasDateAssertedElement()) 8420 composeDateTime(t, "MedicationStatement", "dateAsserted", element.getDateAssertedElement(), -1); 8421 if (element.hasInformationSource()) 8422 composeReference(t, "MedicationStatement", "informationSource", element.getInformationSource(), -1); 8423 if (element.hasSubject()) 8424 composeReference(t, "MedicationStatement", "subject", element.getSubject(), -1); 8425 for (int i = 0; i < element.getDerivedFrom().size(); i++) 8426 composeReference(t, "MedicationStatement", "derivedFrom", element.getDerivedFrom().get(i), i); 8427 if (element.hasTakenElement()) 8428 composeEnum(t, "MedicationStatement", "taken", element.getTakenElement(), -1); 8429 for (int i = 0; i < element.getReasonNotTaken().size(); i++) 8430 composeCodeableConcept(t, "MedicationStatement", "reasonNotTaken", element.getReasonNotTaken().get(i), i); 8431 for (int i = 0; i < element.getReasonCode().size(); i++) 8432 composeCodeableConcept(t, "MedicationStatement", "reasonCode", element.getReasonCode().get(i), i); 8433 for (int i = 0; i < element.getReasonReference().size(); i++) 8434 composeReference(t, "MedicationStatement", "reasonReference", element.getReasonReference().get(i), i); 8435 for (int i = 0; i < element.getNote().size(); i++) 8436 composeAnnotation(t, "MedicationStatement", "note", element.getNote().get(i), i); 8437 for (int i = 0; i < element.getDosage().size(); i++) 8438 composeDosage(t, "MedicationStatement", "dosage", element.getDosage().get(i), i); 8439 } 8440 8441 protected void composeMessageDefinition(Complex parent, String parentType, String name, MessageDefinition element, int index) { 8442 if (element == null) 8443 return; 8444 Complex t; 8445 if (Utilities.noString(parentType)) 8446 t = parent; 8447 else { 8448 t = parent.predicate("fhir:"+parentType+'.'+name); 8449 } 8450 composeDomainResource(t, "MessageDefinition", name, element, index); 8451 if (element.hasUrlElement()) 8452 composeUri(t, "MessageDefinition", "url", element.getUrlElement(), -1); 8453 if (element.hasIdentifier()) 8454 composeIdentifier(t, "MessageDefinition", "identifier", element.getIdentifier(), -1); 8455 if (element.hasVersionElement()) 8456 composeString(t, "MessageDefinition", "version", element.getVersionElement(), -1); 8457 if (element.hasNameElement()) 8458 composeString(t, "MessageDefinition", "name", element.getNameElement(), -1); 8459 if (element.hasTitleElement()) 8460 composeString(t, "MessageDefinition", "title", element.getTitleElement(), -1); 8461 if (element.hasStatusElement()) 8462 composeEnum(t, "MessageDefinition", "status", element.getStatusElement(), -1); 8463 if (element.hasExperimentalElement()) 8464 composeBoolean(t, "MessageDefinition", "experimental", element.getExperimentalElement(), -1); 8465 if (element.hasDateElement()) 8466 composeDateTime(t, "MessageDefinition", "date", element.getDateElement(), -1); 8467 if (element.hasPublisherElement()) 8468 composeString(t, "MessageDefinition", "publisher", element.getPublisherElement(), -1); 8469 for (int i = 0; i < element.getContact().size(); i++) 8470 composeContactDetail(t, "MessageDefinition", "contact", element.getContact().get(i), i); 8471 if (element.hasDescriptionElement()) 8472 composeMarkdown(t, "MessageDefinition", "description", element.getDescriptionElement(), -1); 8473 for (int i = 0; i < element.getUseContext().size(); i++) 8474 composeUsageContext(t, "MessageDefinition", "useContext", element.getUseContext().get(i), i); 8475 for (int i = 0; i < element.getJurisdiction().size(); i++) 8476 composeCodeableConcept(t, "MessageDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 8477 if (element.hasPurposeElement()) 8478 composeMarkdown(t, "MessageDefinition", "purpose", element.getPurposeElement(), -1); 8479 if (element.hasCopyrightElement()) 8480 composeMarkdown(t, "MessageDefinition", "copyright", element.getCopyrightElement(), -1); 8481 if (element.hasBase()) 8482 composeReference(t, "MessageDefinition", "base", element.getBase(), -1); 8483 for (int i = 0; i < element.getParent().size(); i++) 8484 composeReference(t, "MessageDefinition", "parent", element.getParent().get(i), i); 8485 for (int i = 0; i < element.getReplaces().size(); i++) 8486 composeReference(t, "MessageDefinition", "replaces", element.getReplaces().get(i), i); 8487 if (element.hasEvent()) 8488 composeCoding(t, "MessageDefinition", "event", element.getEvent(), -1); 8489 if (element.hasCategoryElement()) 8490 composeEnum(t, "MessageDefinition", "category", element.getCategoryElement(), -1); 8491 for (int i = 0; i < element.getFocus().size(); i++) 8492 composeMessageDefinitionMessageDefinitionFocusComponent(t, "MessageDefinition", "focus", element.getFocus().get(i), i); 8493 if (element.hasResponseRequiredElement()) 8494 composeBoolean(t, "MessageDefinition", "responseRequired", element.getResponseRequiredElement(), -1); 8495 for (int i = 0; i < element.getAllowedResponse().size(); i++) 8496 composeMessageDefinitionMessageDefinitionAllowedResponseComponent(t, "MessageDefinition", "allowedResponse", element.getAllowedResponse().get(i), i); 8497 } 8498 8499 protected void composeMessageDefinitionMessageDefinitionFocusComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionFocusComponent element, int index) { 8500 if (element == null) 8501 return; 8502 Complex t; 8503 if (Utilities.noString(parentType)) 8504 t = parent; 8505 else { 8506 t = parent.predicate("fhir:"+parentType+'.'+name); 8507 } 8508 composeBackboneElement(t, "focus", name, element, index); 8509 if (element.hasCodeElement()) 8510 composeCode(t, "MessageDefinition", "code", element.getCodeElement(), -1); 8511 if (element.hasProfile()) 8512 composeReference(t, "MessageDefinition", "profile", element.getProfile(), -1); 8513 if (element.hasMinElement()) 8514 composeUnsignedInt(t, "MessageDefinition", "min", element.getMinElement(), -1); 8515 if (element.hasMaxElement()) 8516 composeString(t, "MessageDefinition", "max", element.getMaxElement(), -1); 8517 } 8518 8519 protected void composeMessageDefinitionMessageDefinitionAllowedResponseComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionAllowedResponseComponent element, int index) { 8520 if (element == null) 8521 return; 8522 Complex t; 8523 if (Utilities.noString(parentType)) 8524 t = parent; 8525 else { 8526 t = parent.predicate("fhir:"+parentType+'.'+name); 8527 } 8528 composeBackboneElement(t, "allowedResponse", name, element, index); 8529 if (element.hasMessage()) 8530 composeReference(t, "MessageDefinition", "message", element.getMessage(), -1); 8531 if (element.hasSituationElement()) 8532 composeMarkdown(t, "MessageDefinition", "situation", element.getSituationElement(), -1); 8533 } 8534 8535 protected void composeMessageHeader(Complex parent, String parentType, String name, MessageHeader element, int index) { 8536 if (element == null) 8537 return; 8538 Complex t; 8539 if (Utilities.noString(parentType)) 8540 t = parent; 8541 else { 8542 t = parent.predicate("fhir:"+parentType+'.'+name); 8543 } 8544 composeDomainResource(t, "MessageHeader", name, element, index); 8545 if (element.hasEvent()) 8546 composeCoding(t, "MessageHeader", "event", element.getEvent(), -1); 8547 for (int i = 0; i < element.getDestination().size(); i++) 8548 composeMessageHeaderMessageDestinationComponent(t, "MessageHeader", "destination", element.getDestination().get(i), i); 8549 if (element.hasReceiver()) 8550 composeReference(t, "MessageHeader", "receiver", element.getReceiver(), -1); 8551 if (element.hasSender()) 8552 composeReference(t, "MessageHeader", "sender", element.getSender(), -1); 8553 if (element.hasTimestampElement()) 8554 composeInstant(t, "MessageHeader", "timestamp", element.getTimestampElement(), -1); 8555 if (element.hasEnterer()) 8556 composeReference(t, "MessageHeader", "enterer", element.getEnterer(), -1); 8557 if (element.hasAuthor()) 8558 composeReference(t, "MessageHeader", "author", element.getAuthor(), -1); 8559 if (element.hasSource()) 8560 composeMessageHeaderMessageSourceComponent(t, "MessageHeader", "source", element.getSource(), -1); 8561 if (element.hasResponsible()) 8562 composeReference(t, "MessageHeader", "responsible", element.getResponsible(), -1); 8563 if (element.hasReason()) 8564 composeCodeableConcept(t, "MessageHeader", "reason", element.getReason(), -1); 8565 if (element.hasResponse()) 8566 composeMessageHeaderMessageHeaderResponseComponent(t, "MessageHeader", "response", element.getResponse(), -1); 8567 for (int i = 0; i < element.getFocus().size(); i++) 8568 composeReference(t, "MessageHeader", "focus", element.getFocus().get(i), i); 8569 } 8570 8571 protected void composeMessageHeaderMessageDestinationComponent(Complex parent, String parentType, String name, MessageHeader.MessageDestinationComponent element, int index) { 8572 if (element == null) 8573 return; 8574 Complex t; 8575 if (Utilities.noString(parentType)) 8576 t = parent; 8577 else { 8578 t = parent.predicate("fhir:"+parentType+'.'+name); 8579 } 8580 composeBackboneElement(t, "destination", name, element, index); 8581 if (element.hasNameElement()) 8582 composeString(t, "MessageHeader", "name", element.getNameElement(), -1); 8583 if (element.hasTarget()) 8584 composeReference(t, "MessageHeader", "target", element.getTarget(), -1); 8585 if (element.hasEndpointElement()) 8586 composeUri(t, "MessageHeader", "endpoint", element.getEndpointElement(), -1); 8587 } 8588 8589 protected void composeMessageHeaderMessageSourceComponent(Complex parent, String parentType, String name, MessageHeader.MessageSourceComponent element, int index) { 8590 if (element == null) 8591 return; 8592 Complex t; 8593 if (Utilities.noString(parentType)) 8594 t = parent; 8595 else { 8596 t = parent.predicate("fhir:"+parentType+'.'+name); 8597 } 8598 composeBackboneElement(t, "source", name, element, index); 8599 if (element.hasNameElement()) 8600 composeString(t, "MessageHeader", "name", element.getNameElement(), -1); 8601 if (element.hasSoftwareElement()) 8602 composeString(t, "MessageHeader", "software", element.getSoftwareElement(), -1); 8603 if (element.hasVersionElement()) 8604 composeString(t, "MessageHeader", "version", element.getVersionElement(), -1); 8605 if (element.hasContact()) 8606 composeContactPoint(t, "MessageHeader", "contact", element.getContact(), -1); 8607 if (element.hasEndpointElement()) 8608 composeUri(t, "MessageHeader", "endpoint", element.getEndpointElement(), -1); 8609 } 8610 8611 protected void composeMessageHeaderMessageHeaderResponseComponent(Complex parent, String parentType, String name, MessageHeader.MessageHeaderResponseComponent element, int index) { 8612 if (element == null) 8613 return; 8614 Complex t; 8615 if (Utilities.noString(parentType)) 8616 t = parent; 8617 else { 8618 t = parent.predicate("fhir:"+parentType+'.'+name); 8619 } 8620 composeBackboneElement(t, "response", name, element, index); 8621 if (element.hasIdentifierElement()) 8622 composeId(t, "MessageHeader", "identifier", element.getIdentifierElement(), -1); 8623 if (element.hasCodeElement()) 8624 composeEnum(t, "MessageHeader", "code", element.getCodeElement(), -1); 8625 if (element.hasDetails()) 8626 composeReference(t, "MessageHeader", "details", element.getDetails(), -1); 8627 } 8628 8629 protected void composeNamingSystem(Complex parent, String parentType, String name, NamingSystem element, int index) { 8630 if (element == null) 8631 return; 8632 Complex t; 8633 if (Utilities.noString(parentType)) 8634 t = parent; 8635 else { 8636 t = parent.predicate("fhir:"+parentType+'.'+name); 8637 } 8638 composeDomainResource(t, "NamingSystem", name, element, index); 8639 if (element.hasNameElement()) 8640 composeString(t, "NamingSystem", "name", element.getNameElement(), -1); 8641 if (element.hasStatusElement()) 8642 composeEnum(t, "NamingSystem", "status", element.getStatusElement(), -1); 8643 if (element.hasKindElement()) 8644 composeEnum(t, "NamingSystem", "kind", element.getKindElement(), -1); 8645 if (element.hasDateElement()) 8646 composeDateTime(t, "NamingSystem", "date", element.getDateElement(), -1); 8647 if (element.hasPublisherElement()) 8648 composeString(t, "NamingSystem", "publisher", element.getPublisherElement(), -1); 8649 for (int i = 0; i < element.getContact().size(); i++) 8650 composeContactDetail(t, "NamingSystem", "contact", element.getContact().get(i), i); 8651 if (element.hasResponsibleElement()) 8652 composeString(t, "NamingSystem", "responsible", element.getResponsibleElement(), -1); 8653 if (element.hasType()) 8654 composeCodeableConcept(t, "NamingSystem", "type", element.getType(), -1); 8655 if (element.hasDescriptionElement()) 8656 composeMarkdown(t, "NamingSystem", "description", element.getDescriptionElement(), -1); 8657 for (int i = 0; i < element.getUseContext().size(); i++) 8658 composeUsageContext(t, "NamingSystem", "useContext", element.getUseContext().get(i), i); 8659 for (int i = 0; i < element.getJurisdiction().size(); i++) 8660 composeCodeableConcept(t, "NamingSystem", "jurisdiction", element.getJurisdiction().get(i), i); 8661 if (element.hasUsageElement()) 8662 composeString(t, "NamingSystem", "usage", element.getUsageElement(), -1); 8663 for (int i = 0; i < element.getUniqueId().size(); i++) 8664 composeNamingSystemNamingSystemUniqueIdComponent(t, "NamingSystem", "uniqueId", element.getUniqueId().get(i), i); 8665 if (element.hasReplacedBy()) 8666 composeReference(t, "NamingSystem", "replacedBy", element.getReplacedBy(), -1); 8667 } 8668 8669 protected void composeNamingSystemNamingSystemUniqueIdComponent(Complex parent, String parentType, String name, NamingSystem.NamingSystemUniqueIdComponent element, int index) { 8670 if (element == null) 8671 return; 8672 Complex t; 8673 if (Utilities.noString(parentType)) 8674 t = parent; 8675 else { 8676 t = parent.predicate("fhir:"+parentType+'.'+name); 8677 } 8678 composeBackboneElement(t, "uniqueId", name, element, index); 8679 if (element.hasTypeElement()) 8680 composeEnum(t, "NamingSystem", "type", element.getTypeElement(), -1); 8681 if (element.hasValueElement()) 8682 composeString(t, "NamingSystem", "value", element.getValueElement(), -1); 8683 if (element.hasPreferredElement()) 8684 composeBoolean(t, "NamingSystem", "preferred", element.getPreferredElement(), -1); 8685 if (element.hasCommentElement()) 8686 composeString(t, "NamingSystem", "comment", element.getCommentElement(), -1); 8687 if (element.hasPeriod()) 8688 composePeriod(t, "NamingSystem", "period", element.getPeriod(), -1); 8689 } 8690 8691 protected void composeNutritionOrder(Complex parent, String parentType, String name, NutritionOrder element, int index) { 8692 if (element == null) 8693 return; 8694 Complex t; 8695 if (Utilities.noString(parentType)) 8696 t = parent; 8697 else { 8698 t = parent.predicate("fhir:"+parentType+'.'+name); 8699 } 8700 composeDomainResource(t, "NutritionOrder", name, element, index); 8701 for (int i = 0; i < element.getIdentifier().size(); i++) 8702 composeIdentifier(t, "NutritionOrder", "identifier", element.getIdentifier().get(i), i); 8703 if (element.hasStatusElement()) 8704 composeEnum(t, "NutritionOrder", "status", element.getStatusElement(), -1); 8705 if (element.hasPatient()) 8706 composeReference(t, "NutritionOrder", "patient", element.getPatient(), -1); 8707 if (element.hasEncounter()) 8708 composeReference(t, "NutritionOrder", "encounter", element.getEncounter(), -1); 8709 if (element.hasDateTimeElement()) 8710 composeDateTime(t, "NutritionOrder", "dateTime", element.getDateTimeElement(), -1); 8711 if (element.hasOrderer()) 8712 composeReference(t, "NutritionOrder", "orderer", element.getOrderer(), -1); 8713 for (int i = 0; i < element.getAllergyIntolerance().size(); i++) 8714 composeReference(t, "NutritionOrder", "allergyIntolerance", element.getAllergyIntolerance().get(i), i); 8715 for (int i = 0; i < element.getFoodPreferenceModifier().size(); i++) 8716 composeCodeableConcept(t, "NutritionOrder", "foodPreferenceModifier", element.getFoodPreferenceModifier().get(i), i); 8717 for (int i = 0; i < element.getExcludeFoodModifier().size(); i++) 8718 composeCodeableConcept(t, "NutritionOrder", "excludeFoodModifier", element.getExcludeFoodModifier().get(i), i); 8719 if (element.hasOralDiet()) 8720 composeNutritionOrderNutritionOrderOralDietComponent(t, "NutritionOrder", "oralDiet", element.getOralDiet(), -1); 8721 for (int i = 0; i < element.getSupplement().size(); i++) 8722 composeNutritionOrderNutritionOrderSupplementComponent(t, "NutritionOrder", "supplement", element.getSupplement().get(i), i); 8723 if (element.hasEnteralFormula()) 8724 composeNutritionOrderNutritionOrderEnteralFormulaComponent(t, "NutritionOrder", "enteralFormula", element.getEnteralFormula(), -1); 8725 } 8726 8727 protected void composeNutritionOrderNutritionOrderOralDietComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietComponent element, int index) { 8728 if (element == null) 8729 return; 8730 Complex t; 8731 if (Utilities.noString(parentType)) 8732 t = parent; 8733 else { 8734 t = parent.predicate("fhir:"+parentType+'.'+name); 8735 } 8736 composeBackboneElement(t, "oralDiet", name, element, index); 8737 for (int i = 0; i < element.getType().size(); i++) 8738 composeCodeableConcept(t, "NutritionOrder", "type", element.getType().get(i), i); 8739 for (int i = 0; i < element.getSchedule().size(); i++) 8740 composeTiming(t, "NutritionOrder", "schedule", element.getSchedule().get(i), i); 8741 for (int i = 0; i < element.getNutrient().size(); i++) 8742 composeNutritionOrderNutritionOrderOralDietNutrientComponent(t, "NutritionOrder", "nutrient", element.getNutrient().get(i), i); 8743 for (int i = 0; i < element.getTexture().size(); i++) 8744 composeNutritionOrderNutritionOrderOralDietTextureComponent(t, "NutritionOrder", "texture", element.getTexture().get(i), i); 8745 for (int i = 0; i < element.getFluidConsistencyType().size(); i++) 8746 composeCodeableConcept(t, "NutritionOrder", "fluidConsistencyType", element.getFluidConsistencyType().get(i), i); 8747 if (element.hasInstructionElement()) 8748 composeString(t, "NutritionOrder", "instruction", element.getInstructionElement(), -1); 8749 } 8750 8751 protected void composeNutritionOrderNutritionOrderOralDietNutrientComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietNutrientComponent element, int index) { 8752 if (element == null) 8753 return; 8754 Complex t; 8755 if (Utilities.noString(parentType)) 8756 t = parent; 8757 else { 8758 t = parent.predicate("fhir:"+parentType+'.'+name); 8759 } 8760 composeBackboneElement(t, "nutrient", name, element, index); 8761 if (element.hasModifier()) 8762 composeCodeableConcept(t, "NutritionOrder", "modifier", element.getModifier(), -1); 8763 if (element.hasAmount()) 8764 composeQuantity(t, "NutritionOrder", "amount", element.getAmount(), -1); 8765 } 8766 8767 protected void composeNutritionOrderNutritionOrderOralDietTextureComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietTextureComponent element, int index) { 8768 if (element == null) 8769 return; 8770 Complex t; 8771 if (Utilities.noString(parentType)) 8772 t = parent; 8773 else { 8774 t = parent.predicate("fhir:"+parentType+'.'+name); 8775 } 8776 composeBackboneElement(t, "texture", name, element, index); 8777 if (element.hasModifier()) 8778 composeCodeableConcept(t, "NutritionOrder", "modifier", element.getModifier(), -1); 8779 if (element.hasFoodType()) 8780 composeCodeableConcept(t, "NutritionOrder", "foodType", element.getFoodType(), -1); 8781 } 8782 8783 protected void composeNutritionOrderNutritionOrderSupplementComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderSupplementComponent element, int index) { 8784 if (element == null) 8785 return; 8786 Complex t; 8787 if (Utilities.noString(parentType)) 8788 t = parent; 8789 else { 8790 t = parent.predicate("fhir:"+parentType+'.'+name); 8791 } 8792 composeBackboneElement(t, "supplement", name, element, index); 8793 if (element.hasType()) 8794 composeCodeableConcept(t, "NutritionOrder", "type", element.getType(), -1); 8795 if (element.hasProductNameElement()) 8796 composeString(t, "NutritionOrder", "productName", element.getProductNameElement(), -1); 8797 for (int i = 0; i < element.getSchedule().size(); i++) 8798 composeTiming(t, "NutritionOrder", "schedule", element.getSchedule().get(i), i); 8799 if (element.hasQuantity()) 8800 composeQuantity(t, "NutritionOrder", "quantity", element.getQuantity(), -1); 8801 if (element.hasInstructionElement()) 8802 composeString(t, "NutritionOrder", "instruction", element.getInstructionElement(), -1); 8803 } 8804 8805 protected void composeNutritionOrderNutritionOrderEnteralFormulaComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaComponent element, int index) { 8806 if (element == null) 8807 return; 8808 Complex t; 8809 if (Utilities.noString(parentType)) 8810 t = parent; 8811 else { 8812 t = parent.predicate("fhir:"+parentType+'.'+name); 8813 } 8814 composeBackboneElement(t, "enteralFormula", name, element, index); 8815 if (element.hasBaseFormulaType()) 8816 composeCodeableConcept(t, "NutritionOrder", "baseFormulaType", element.getBaseFormulaType(), -1); 8817 if (element.hasBaseFormulaProductNameElement()) 8818 composeString(t, "NutritionOrder", "baseFormulaProductName", element.getBaseFormulaProductNameElement(), -1); 8819 if (element.hasAdditiveType()) 8820 composeCodeableConcept(t, "NutritionOrder", "additiveType", element.getAdditiveType(), -1); 8821 if (element.hasAdditiveProductNameElement()) 8822 composeString(t, "NutritionOrder", "additiveProductName", element.getAdditiveProductNameElement(), -1); 8823 if (element.hasCaloricDensity()) 8824 composeQuantity(t, "NutritionOrder", "caloricDensity", element.getCaloricDensity(), -1); 8825 if (element.hasRouteofAdministration()) 8826 composeCodeableConcept(t, "NutritionOrder", "routeofAdministration", element.getRouteofAdministration(), -1); 8827 for (int i = 0; i < element.getAdministration().size(); i++) 8828 composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(t, "NutritionOrder", "administration", element.getAdministration().get(i), i); 8829 if (element.hasMaxVolumeToDeliver()) 8830 composeQuantity(t, "NutritionOrder", "maxVolumeToDeliver", element.getMaxVolumeToDeliver(), -1); 8831 if (element.hasAdministrationInstructionElement()) 8832 composeString(t, "NutritionOrder", "administrationInstruction", element.getAdministrationInstructionElement(), -1); 8833 } 8834 8835 protected void composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent element, int index) { 8836 if (element == null) 8837 return; 8838 Complex t; 8839 if (Utilities.noString(parentType)) 8840 t = parent; 8841 else { 8842 t = parent.predicate("fhir:"+parentType+'.'+name); 8843 } 8844 composeBackboneElement(t, "administration", name, element, index); 8845 if (element.hasSchedule()) 8846 composeTiming(t, "NutritionOrder", "schedule", element.getSchedule(), -1); 8847 if (element.hasQuantity()) 8848 composeQuantity(t, "NutritionOrder", "quantity", element.getQuantity(), -1); 8849 if (element.hasRate()) 8850 composeType(t, "NutritionOrder", "rate", element.getRate(), -1); 8851 } 8852 8853 protected void composeObservation(Complex parent, String parentType, String name, Observation element, int index) { 8854 if (element == null) 8855 return; 8856 Complex t; 8857 if (Utilities.noString(parentType)) 8858 t = parent; 8859 else { 8860 t = parent.predicate("fhir:"+parentType+'.'+name); 8861 } 8862 composeDomainResource(t, "Observation", name, element, index); 8863 for (int i = 0; i < element.getIdentifier().size(); i++) 8864 composeIdentifier(t, "Observation", "identifier", element.getIdentifier().get(i), i); 8865 for (int i = 0; i < element.getBasedOn().size(); i++) 8866 composeReference(t, "Observation", "basedOn", element.getBasedOn().get(i), i); 8867 if (element.hasStatusElement()) 8868 composeEnum(t, "Observation", "status", element.getStatusElement(), -1); 8869 for (int i = 0; i < element.getCategory().size(); i++) 8870 composeCodeableConcept(t, "Observation", "category", element.getCategory().get(i), i); 8871 if (element.hasCode()) 8872 composeCodeableConcept(t, "Observation", "code", element.getCode(), -1); 8873 if (element.hasSubject()) 8874 composeReference(t, "Observation", "subject", element.getSubject(), -1); 8875 if (element.hasContext()) 8876 composeReference(t, "Observation", "context", element.getContext(), -1); 8877 if (element.hasEffective()) 8878 composeType(t, "Observation", "effective", element.getEffective(), -1); 8879 if (element.hasIssuedElement()) 8880 composeInstant(t, "Observation", "issued", element.getIssuedElement(), -1); 8881 for (int i = 0; i < element.getPerformer().size(); i++) 8882 composeReference(t, "Observation", "performer", element.getPerformer().get(i), i); 8883 if (element.hasValue()) 8884 composeType(t, "Observation", "value", element.getValue(), -1); 8885 if (element.hasDataAbsentReason()) 8886 composeCodeableConcept(t, "Observation", "dataAbsentReason", element.getDataAbsentReason(), -1); 8887 if (element.hasInterpretation()) 8888 composeCodeableConcept(t, "Observation", "interpretation", element.getInterpretation(), -1); 8889 if (element.hasCommentElement()) 8890 composeString(t, "Observation", "comment", element.getCommentElement(), -1); 8891 if (element.hasBodySite()) 8892 composeCodeableConcept(t, "Observation", "bodySite", element.getBodySite(), -1); 8893 if (element.hasMethod()) 8894 composeCodeableConcept(t, "Observation", "method", element.getMethod(), -1); 8895 if (element.hasSpecimen()) 8896 composeReference(t, "Observation", "specimen", element.getSpecimen(), -1); 8897 if (element.hasDevice()) 8898 composeReference(t, "Observation", "device", element.getDevice(), -1); 8899 for (int i = 0; i < element.getReferenceRange().size(); i++) 8900 composeObservationObservationReferenceRangeComponent(t, "Observation", "referenceRange", element.getReferenceRange().get(i), i); 8901 for (int i = 0; i < element.getRelated().size(); i++) 8902 composeObservationObservationRelatedComponent(t, "Observation", "related", element.getRelated().get(i), i); 8903 for (int i = 0; i < element.getComponent().size(); i++) 8904 composeObservationObservationComponentComponent(t, "Observation", "component", element.getComponent().get(i), i); 8905 } 8906 8907 protected void composeObservationObservationReferenceRangeComponent(Complex parent, String parentType, String name, Observation.ObservationReferenceRangeComponent element, int index) { 8908 if (element == null) 8909 return; 8910 Complex t; 8911 if (Utilities.noString(parentType)) 8912 t = parent; 8913 else { 8914 t = parent.predicate("fhir:"+parentType+'.'+name); 8915 } 8916 composeBackboneElement(t, "referenceRange", name, element, index); 8917 if (element.hasLow()) 8918 composeQuantity(t, "Observation", "low", element.getLow(), -1); 8919 if (element.hasHigh()) 8920 composeQuantity(t, "Observation", "high", element.getHigh(), -1); 8921 if (element.hasType()) 8922 composeCodeableConcept(t, "Observation", "type", element.getType(), -1); 8923 for (int i = 0; i < element.getAppliesTo().size(); i++) 8924 composeCodeableConcept(t, "Observation", "appliesTo", element.getAppliesTo().get(i), i); 8925 if (element.hasAge()) 8926 composeRange(t, "Observation", "age", element.getAge(), -1); 8927 if (element.hasTextElement()) 8928 composeString(t, "Observation", "text", element.getTextElement(), -1); 8929 } 8930 8931 protected void composeObservationObservationRelatedComponent(Complex parent, String parentType, String name, Observation.ObservationRelatedComponent element, int index) { 8932 if (element == null) 8933 return; 8934 Complex t; 8935 if (Utilities.noString(parentType)) 8936 t = parent; 8937 else { 8938 t = parent.predicate("fhir:"+parentType+'.'+name); 8939 } 8940 composeBackboneElement(t, "related", name, element, index); 8941 if (element.hasTypeElement()) 8942 composeEnum(t, "Observation", "type", element.getTypeElement(), -1); 8943 if (element.hasTarget()) 8944 composeReference(t, "Observation", "target", element.getTarget(), -1); 8945 } 8946 8947 protected void composeObservationObservationComponentComponent(Complex parent, String parentType, String name, Observation.ObservationComponentComponent element, int index) { 8948 if (element == null) 8949 return; 8950 Complex t; 8951 if (Utilities.noString(parentType)) 8952 t = parent; 8953 else { 8954 t = parent.predicate("fhir:"+parentType+'.'+name); 8955 } 8956 composeBackboneElement(t, "component", name, element, index); 8957 if (element.hasCode()) 8958 composeCodeableConcept(t, "Observation", "code", element.getCode(), -1); 8959 if (element.hasValue()) 8960 composeType(t, "Observation", "value", element.getValue(), -1); 8961 if (element.hasDataAbsentReason()) 8962 composeCodeableConcept(t, "Observation", "dataAbsentReason", element.getDataAbsentReason(), -1); 8963 if (element.hasInterpretation()) 8964 composeCodeableConcept(t, "Observation", "interpretation", element.getInterpretation(), -1); 8965 for (int i = 0; i < element.getReferenceRange().size(); i++) 8966 composeObservationObservationReferenceRangeComponent(t, "Observation", "referenceRange", element.getReferenceRange().get(i), i); 8967 } 8968 8969 protected void composeOperationDefinition(Complex parent, String parentType, String name, OperationDefinition element, int index) { 8970 if (element == null) 8971 return; 8972 Complex t; 8973 if (Utilities.noString(parentType)) 8974 t = parent; 8975 else { 8976 t = parent.predicate("fhir:"+parentType+'.'+name); 8977 } 8978 composeDomainResource(t, "OperationDefinition", name, element, index); 8979 if (element.hasUrlElement()) 8980 composeUri(t, "OperationDefinition", "url", element.getUrlElement(), -1); 8981 if (element.hasVersionElement()) 8982 composeString(t, "OperationDefinition", "version", element.getVersionElement(), -1); 8983 if (element.hasNameElement()) 8984 composeString(t, "OperationDefinition", "name", element.getNameElement(), -1); 8985 if (element.hasStatusElement()) 8986 composeEnum(t, "OperationDefinition", "status", element.getStatusElement(), -1); 8987 if (element.hasKindElement()) 8988 composeEnum(t, "OperationDefinition", "kind", element.getKindElement(), -1); 8989 if (element.hasExperimentalElement()) 8990 composeBoolean(t, "OperationDefinition", "experimental", element.getExperimentalElement(), -1); 8991 if (element.hasDateElement()) 8992 composeDateTime(t, "OperationDefinition", "date", element.getDateElement(), -1); 8993 if (element.hasPublisherElement()) 8994 composeString(t, "OperationDefinition", "publisher", element.getPublisherElement(), -1); 8995 for (int i = 0; i < element.getContact().size(); i++) 8996 composeContactDetail(t, "OperationDefinition", "contact", element.getContact().get(i), i); 8997 if (element.hasDescriptionElement()) 8998 composeMarkdown(t, "OperationDefinition", "description", element.getDescriptionElement(), -1); 8999 for (int i = 0; i < element.getUseContext().size(); i++) 9000 composeUsageContext(t, "OperationDefinition", "useContext", element.getUseContext().get(i), i); 9001 for (int i = 0; i < element.getJurisdiction().size(); i++) 9002 composeCodeableConcept(t, "OperationDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 9003 if (element.hasPurposeElement()) 9004 composeMarkdown(t, "OperationDefinition", "purpose", element.getPurposeElement(), -1); 9005 if (element.hasIdempotentElement()) 9006 composeBoolean(t, "OperationDefinition", "idempotent", element.getIdempotentElement(), -1); 9007 if (element.hasCodeElement()) 9008 composeCode(t, "OperationDefinition", "code", element.getCodeElement(), -1); 9009 if (element.hasCommentElement()) 9010 composeString(t, "OperationDefinition", "comment", element.getCommentElement(), -1); 9011 if (element.hasBase()) 9012 composeReference(t, "OperationDefinition", "base", element.getBase(), -1); 9013 for (int i = 0; i < element.getResource().size(); i++) 9014 composeCode(t, "OperationDefinition", "resource", element.getResource().get(i), i); 9015 if (element.hasSystemElement()) 9016 composeBoolean(t, "OperationDefinition", "system", element.getSystemElement(), -1); 9017 if (element.hasTypeElement()) 9018 composeBoolean(t, "OperationDefinition", "type", element.getTypeElement(), -1); 9019 if (element.hasInstanceElement()) 9020 composeBoolean(t, "OperationDefinition", "instance", element.getInstanceElement(), -1); 9021 for (int i = 0; i < element.getParameter().size(); i++) 9022 composeOperationDefinitionOperationDefinitionParameterComponent(t, "OperationDefinition", "parameter", element.getParameter().get(i), i); 9023 for (int i = 0; i < element.getOverload().size(); i++) 9024 composeOperationDefinitionOperationDefinitionOverloadComponent(t, "OperationDefinition", "overload", element.getOverload().get(i), i); 9025 } 9026 9027 protected void composeOperationDefinitionOperationDefinitionParameterComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterComponent element, int index) { 9028 if (element == null) 9029 return; 9030 Complex t; 9031 if (Utilities.noString(parentType)) 9032 t = parent; 9033 else { 9034 t = parent.predicate("fhir:"+parentType+'.'+name); 9035 } 9036 composeBackboneElement(t, "parameter", name, element, index); 9037 if (element.hasNameElement()) 9038 composeCode(t, "OperationDefinition", "name", element.getNameElement(), -1); 9039 if (element.hasUseElement()) 9040 composeEnum(t, "OperationDefinition", "use", element.getUseElement(), -1); 9041 if (element.hasMinElement()) 9042 composeInteger(t, "OperationDefinition", "min", element.getMinElement(), -1); 9043 if (element.hasMaxElement()) 9044 composeString(t, "OperationDefinition", "max", element.getMaxElement(), -1); 9045 if (element.hasDocumentationElement()) 9046 composeString(t, "OperationDefinition", "documentation", element.getDocumentationElement(), -1); 9047 if (element.hasTypeElement()) 9048 composeCode(t, "OperationDefinition", "type", element.getTypeElement(), -1); 9049 if (element.hasSearchTypeElement()) 9050 composeEnum(t, "OperationDefinition", "searchType", element.getSearchTypeElement(), -1); 9051 if (element.hasProfile()) 9052 composeReference(t, "OperationDefinition", "profile", element.getProfile(), -1); 9053 if (element.hasBinding()) 9054 composeOperationDefinitionOperationDefinitionParameterBindingComponent(t, "OperationDefinition", "binding", element.getBinding(), -1); 9055 for (int i = 0; i < element.getPart().size(); i++) 9056 composeOperationDefinitionOperationDefinitionParameterComponent(t, "OperationDefinition", "part", element.getPart().get(i), i); 9057 } 9058 9059 protected void composeOperationDefinitionOperationDefinitionParameterBindingComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterBindingComponent element, int index) { 9060 if (element == null) 9061 return; 9062 Complex t; 9063 if (Utilities.noString(parentType)) 9064 t = parent; 9065 else { 9066 t = parent.predicate("fhir:"+parentType+'.'+name); 9067 } 9068 composeBackboneElement(t, "binding", name, element, index); 9069 if (element.hasStrengthElement()) 9070 composeEnum(t, "OperationDefinition", "strength", element.getStrengthElement(), -1); 9071 if (element.hasValueSet()) 9072 composeType(t, "OperationDefinition", "valueSet", element.getValueSet(), -1); 9073 } 9074 9075 protected void composeOperationDefinitionOperationDefinitionOverloadComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionOverloadComponent element, int index) { 9076 if (element == null) 9077 return; 9078 Complex t; 9079 if (Utilities.noString(parentType)) 9080 t = parent; 9081 else { 9082 t = parent.predicate("fhir:"+parentType+'.'+name); 9083 } 9084 composeBackboneElement(t, "overload", name, element, index); 9085 for (int i = 0; i < element.getParameterName().size(); i++) 9086 composeString(t, "OperationDefinition", "parameterName", element.getParameterName().get(i), i); 9087 if (element.hasCommentElement()) 9088 composeString(t, "OperationDefinition", "comment", element.getCommentElement(), -1); 9089 } 9090 9091 protected void composeOperationOutcome(Complex parent, String parentType, String name, OperationOutcome element, int index) { 9092 if (element == null) 9093 return; 9094 Complex t; 9095 if (Utilities.noString(parentType)) 9096 t = parent; 9097 else { 9098 t = parent.predicate("fhir:"+parentType+'.'+name); 9099 } 9100 composeDomainResource(t, "OperationOutcome", name, element, index); 9101 for (int i = 0; i < element.getIssue().size(); i++) 9102 composeOperationOutcomeOperationOutcomeIssueComponent(t, "OperationOutcome", "issue", element.getIssue().get(i), i); 9103 } 9104 9105 protected void composeOperationOutcomeOperationOutcomeIssueComponent(Complex parent, String parentType, String name, OperationOutcome.OperationOutcomeIssueComponent element, int index) { 9106 if (element == null) 9107 return; 9108 Complex t; 9109 if (Utilities.noString(parentType)) 9110 t = parent; 9111 else { 9112 t = parent.predicate("fhir:"+parentType+'.'+name); 9113 } 9114 composeBackboneElement(t, "issue", name, element, index); 9115 if (element.hasSeverityElement()) 9116 composeEnum(t, "OperationOutcome", "severity", element.getSeverityElement(), -1); 9117 if (element.hasCodeElement()) 9118 composeEnum(t, "OperationOutcome", "code", element.getCodeElement(), -1); 9119 if (element.hasDetails()) 9120 composeCodeableConcept(t, "OperationOutcome", "details", element.getDetails(), -1); 9121 if (element.hasDiagnosticsElement()) 9122 composeString(t, "OperationOutcome", "diagnostics", element.getDiagnosticsElement(), -1); 9123 for (int i = 0; i < element.getLocation().size(); i++) 9124 composeString(t, "OperationOutcome", "location", element.getLocation().get(i), i); 9125 for (int i = 0; i < element.getExpression().size(); i++) 9126 composeString(t, "OperationOutcome", "expression", element.getExpression().get(i), i); 9127 } 9128 9129 protected void composeOrganization(Complex parent, String parentType, String name, Organization element, int index) { 9130 if (element == null) 9131 return; 9132 Complex t; 9133 if (Utilities.noString(parentType)) 9134 t = parent; 9135 else { 9136 t = parent.predicate("fhir:"+parentType+'.'+name); 9137 } 9138 composeDomainResource(t, "Organization", name, element, index); 9139 for (int i = 0; i < element.getIdentifier().size(); i++) 9140 composeIdentifier(t, "Organization", "identifier", element.getIdentifier().get(i), i); 9141 if (element.hasActiveElement()) 9142 composeBoolean(t, "Organization", "active", element.getActiveElement(), -1); 9143 for (int i = 0; i < element.getType().size(); i++) 9144 composeCodeableConcept(t, "Organization", "type", element.getType().get(i), i); 9145 if (element.hasNameElement()) 9146 composeString(t, "Organization", "name", element.getNameElement(), -1); 9147 for (int i = 0; i < element.getAlias().size(); i++) 9148 composeString(t, "Organization", "alias", element.getAlias().get(i), i); 9149 for (int i = 0; i < element.getTelecom().size(); i++) 9150 composeContactPoint(t, "Organization", "telecom", element.getTelecom().get(i), i); 9151 for (int i = 0; i < element.getAddress().size(); i++) 9152 composeAddress(t, "Organization", "address", element.getAddress().get(i), i); 9153 if (element.hasPartOf()) 9154 composeReference(t, "Organization", "partOf", element.getPartOf(), -1); 9155 for (int i = 0; i < element.getContact().size(); i++) 9156 composeOrganizationOrganizationContactComponent(t, "Organization", "contact", element.getContact().get(i), i); 9157 for (int i = 0; i < element.getEndpoint().size(); i++) 9158 composeReference(t, "Organization", "endpoint", element.getEndpoint().get(i), i); 9159 } 9160 9161 protected void composeOrganizationOrganizationContactComponent(Complex parent, String parentType, String name, Organization.OrganizationContactComponent element, int index) { 9162 if (element == null) 9163 return; 9164 Complex t; 9165 if (Utilities.noString(parentType)) 9166 t = parent; 9167 else { 9168 t = parent.predicate("fhir:"+parentType+'.'+name); 9169 } 9170 composeBackboneElement(t, "contact", name, element, index); 9171 if (element.hasPurpose()) 9172 composeCodeableConcept(t, "Organization", "purpose", element.getPurpose(), -1); 9173 if (element.hasName()) 9174 composeHumanName(t, "Organization", "name", element.getName(), -1); 9175 for (int i = 0; i < element.getTelecom().size(); i++) 9176 composeContactPoint(t, "Organization", "telecom", element.getTelecom().get(i), i); 9177 if (element.hasAddress()) 9178 composeAddress(t, "Organization", "address", element.getAddress(), -1); 9179 } 9180 9181 protected void composePatient(Complex parent, String parentType, String name, Patient 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:"+parentType+'.'+name); 9189 } 9190 composeDomainResource(t, "Patient", name, element, index); 9191 for (int i = 0; i < element.getIdentifier().size(); i++) 9192 composeIdentifier(t, "Patient", "identifier", element.getIdentifier().get(i), i); 9193 if (element.hasActiveElement()) 9194 composeBoolean(t, "Patient", "active", element.getActiveElement(), -1); 9195 for (int i = 0; i < element.getName().size(); i++) 9196 composeHumanName(t, "Patient", "name", element.getName().get(i), i); 9197 for (int i = 0; i < element.getTelecom().size(); i++) 9198 composeContactPoint(t, "Patient", "telecom", element.getTelecom().get(i), i); 9199 if (element.hasGenderElement()) 9200 composeEnum(t, "Patient", "gender", element.getGenderElement(), -1); 9201 if (element.hasBirthDateElement()) 9202 composeDate(t, "Patient", "birthDate", element.getBirthDateElement(), -1); 9203 if (element.hasDeceased()) 9204 composeType(t, "Patient", "deceased", element.getDeceased(), -1); 9205 for (int i = 0; i < element.getAddress().size(); i++) 9206 composeAddress(t, "Patient", "address", element.getAddress().get(i), i); 9207 if (element.hasMaritalStatus()) 9208 composeCodeableConcept(t, "Patient", "maritalStatus", element.getMaritalStatus(), -1); 9209 if (element.hasMultipleBirth()) 9210 composeType(t, "Patient", "multipleBirth", element.getMultipleBirth(), -1); 9211 for (int i = 0; i < element.getPhoto().size(); i++) 9212 composeAttachment(t, "Patient", "photo", element.getPhoto().get(i), i); 9213 for (int i = 0; i < element.getContact().size(); i++) 9214 composePatientContactComponent(t, "Patient", "contact", element.getContact().get(i), i); 9215 if (element.hasAnimal()) 9216 composePatientAnimalComponent(t, "Patient", "animal", element.getAnimal(), -1); 9217 for (int i = 0; i < element.getCommunication().size(); i++) 9218 composePatientPatientCommunicationComponent(t, "Patient", "communication", element.getCommunication().get(i), i); 9219 for (int i = 0; i < element.getGeneralPractitioner().size(); i++) 9220 composeReference(t, "Patient", "generalPractitioner", element.getGeneralPractitioner().get(i), i); 9221 if (element.hasManagingOrganization()) 9222 composeReference(t, "Patient", "managingOrganization", element.getManagingOrganization(), -1); 9223 for (int i = 0; i < element.getLink().size(); i++) 9224 composePatientPatientLinkComponent(t, "Patient", "link", element.getLink().get(i), i); 9225 } 9226 9227 protected void composePatientContactComponent(Complex parent, String parentType, String name, Patient.ContactComponent element, int index) { 9228 if (element == null) 9229 return; 9230 Complex t; 9231 if (Utilities.noString(parentType)) 9232 t = parent; 9233 else { 9234 t = parent.predicate("fhir:"+parentType+'.'+name); 9235 } 9236 composeBackboneElement(t, "contact", name, element, index); 9237 for (int i = 0; i < element.getRelationship().size(); i++) 9238 composeCodeableConcept(t, "Patient", "relationship", element.getRelationship().get(i), i); 9239 if (element.hasName()) 9240 composeHumanName(t, "Patient", "name", element.getName(), -1); 9241 for (int i = 0; i < element.getTelecom().size(); i++) 9242 composeContactPoint(t, "Patient", "telecom", element.getTelecom().get(i), i); 9243 if (element.hasAddress()) 9244 composeAddress(t, "Patient", "address", element.getAddress(), -1); 9245 if (element.hasGenderElement()) 9246 composeEnum(t, "Patient", "gender", element.getGenderElement(), -1); 9247 if (element.hasOrganization()) 9248 composeReference(t, "Patient", "organization", element.getOrganization(), -1); 9249 if (element.hasPeriod()) 9250 composePeriod(t, "Patient", "period", element.getPeriod(), -1); 9251 } 9252 9253 protected void composePatientAnimalComponent(Complex parent, String parentType, String name, Patient.AnimalComponent element, int index) { 9254 if (element == null) 9255 return; 9256 Complex t; 9257 if (Utilities.noString(parentType)) 9258 t = parent; 9259 else { 9260 t = parent.predicate("fhir:"+parentType+'.'+name); 9261 } 9262 composeBackboneElement(t, "animal", name, element, index); 9263 if (element.hasSpecies()) 9264 composeCodeableConcept(t, "Patient", "species", element.getSpecies(), -1); 9265 if (element.hasBreed()) 9266 composeCodeableConcept(t, "Patient", "breed", element.getBreed(), -1); 9267 if (element.hasGenderStatus()) 9268 composeCodeableConcept(t, "Patient", "genderStatus", element.getGenderStatus(), -1); 9269 } 9270 9271 protected void composePatientPatientCommunicationComponent(Complex parent, String parentType, String name, Patient.PatientCommunicationComponent element, int index) { 9272 if (element == null) 9273 return; 9274 Complex t; 9275 if (Utilities.noString(parentType)) 9276 t = parent; 9277 else { 9278 t = parent.predicate("fhir:"+parentType+'.'+name); 9279 } 9280 composeBackboneElement(t, "communication", name, element, index); 9281 if (element.hasLanguage()) 9282 composeCodeableConcept(t, "Patient", "language", element.getLanguage(), -1); 9283 if (element.hasPreferredElement()) 9284 composeBoolean(t, "Patient", "preferred", element.getPreferredElement(), -1); 9285 } 9286 9287 protected void composePatientPatientLinkComponent(Complex parent, String parentType, String name, Patient.PatientLinkComponent element, int index) { 9288 if (element == null) 9289 return; 9290 Complex t; 9291 if (Utilities.noString(parentType)) 9292 t = parent; 9293 else { 9294 t = parent.predicate("fhir:"+parentType+'.'+name); 9295 } 9296 composeBackboneElement(t, "link", name, element, index); 9297 if (element.hasOther()) 9298 composeReference(t, "Patient", "other", element.getOther(), -1); 9299 if (element.hasTypeElement()) 9300 composeEnum(t, "Patient", "type", element.getTypeElement(), -1); 9301 } 9302 9303 protected void composePaymentNotice(Complex parent, String parentType, String name, PaymentNotice element, int index) { 9304 if (element == null) 9305 return; 9306 Complex t; 9307 if (Utilities.noString(parentType)) 9308 t = parent; 9309 else { 9310 t = parent.predicate("fhir:"+parentType+'.'+name); 9311 } 9312 composeDomainResource(t, "PaymentNotice", name, element, index); 9313 for (int i = 0; i < element.getIdentifier().size(); i++) 9314 composeIdentifier(t, "PaymentNotice", "identifier", element.getIdentifier().get(i), i); 9315 if (element.hasStatusElement()) 9316 composeEnum(t, "PaymentNotice", "status", element.getStatusElement(), -1); 9317 if (element.hasRequest()) 9318 composeReference(t, "PaymentNotice", "request", element.getRequest(), -1); 9319 if (element.hasResponse()) 9320 composeReference(t, "PaymentNotice", "response", element.getResponse(), -1); 9321 if (element.hasStatusDateElement()) 9322 composeDate(t, "PaymentNotice", "statusDate", element.getStatusDateElement(), -1); 9323 if (element.hasCreatedElement()) 9324 composeDateTime(t, "PaymentNotice", "created", element.getCreatedElement(), -1); 9325 if (element.hasTarget()) 9326 composeReference(t, "PaymentNotice", "target", element.getTarget(), -1); 9327 if (element.hasProvider()) 9328 composeReference(t, "PaymentNotice", "provider", element.getProvider(), -1); 9329 if (element.hasOrganization()) 9330 composeReference(t, "PaymentNotice", "organization", element.getOrganization(), -1); 9331 if (element.hasPaymentStatus()) 9332 composeCodeableConcept(t, "PaymentNotice", "paymentStatus", element.getPaymentStatus(), -1); 9333 } 9334 9335 protected void composePaymentReconciliation(Complex parent, String parentType, String name, PaymentReconciliation element, int index) { 9336 if (element == null) 9337 return; 9338 Complex t; 9339 if (Utilities.noString(parentType)) 9340 t = parent; 9341 else { 9342 t = parent.predicate("fhir:"+parentType+'.'+name); 9343 } 9344 composeDomainResource(t, "PaymentReconciliation", name, element, index); 9345 for (int i = 0; i < element.getIdentifier().size(); i++) 9346 composeIdentifier(t, "PaymentReconciliation", "identifier", element.getIdentifier().get(i), i); 9347 if (element.hasStatusElement()) 9348 composeEnum(t, "PaymentReconciliation", "status", element.getStatusElement(), -1); 9349 if (element.hasPeriod()) 9350 composePeriod(t, "PaymentReconciliation", "period", element.getPeriod(), -1); 9351 if (element.hasCreatedElement()) 9352 composeDateTime(t, "PaymentReconciliation", "created", element.getCreatedElement(), -1); 9353 if (element.hasOrganization()) 9354 composeReference(t, "PaymentReconciliation", "organization", element.getOrganization(), -1); 9355 if (element.hasRequest()) 9356 composeReference(t, "PaymentReconciliation", "request", element.getRequest(), -1); 9357 if (element.hasOutcome()) 9358 composeCodeableConcept(t, "PaymentReconciliation", "outcome", element.getOutcome(), -1); 9359 if (element.hasDispositionElement()) 9360 composeString(t, "PaymentReconciliation", "disposition", element.getDispositionElement(), -1); 9361 if (element.hasRequestProvider()) 9362 composeReference(t, "PaymentReconciliation", "requestProvider", element.getRequestProvider(), -1); 9363 if (element.hasRequestOrganization()) 9364 composeReference(t, "PaymentReconciliation", "requestOrganization", element.getRequestOrganization(), -1); 9365 for (int i = 0; i < element.getDetail().size(); i++) 9366 composePaymentReconciliationDetailsComponent(t, "PaymentReconciliation", "detail", element.getDetail().get(i), i); 9367 if (element.hasForm()) 9368 composeCodeableConcept(t, "PaymentReconciliation", "form", element.getForm(), -1); 9369 if (element.hasTotal()) 9370 composeMoney(t, "PaymentReconciliation", "total", element.getTotal(), -1); 9371 for (int i = 0; i < element.getProcessNote().size(); i++) 9372 composePaymentReconciliationNotesComponent(t, "PaymentReconciliation", "processNote", element.getProcessNote().get(i), i); 9373 } 9374 9375 protected void composePaymentReconciliationDetailsComponent(Complex parent, String parentType, String name, PaymentReconciliation.DetailsComponent element, int index) { 9376 if (element == null) 9377 return; 9378 Complex t; 9379 if (Utilities.noString(parentType)) 9380 t = parent; 9381 else { 9382 t = parent.predicate("fhir:"+parentType+'.'+name); 9383 } 9384 composeBackboneElement(t, "detail", name, element, index); 9385 if (element.hasType()) 9386 composeCodeableConcept(t, "PaymentReconciliation", "type", element.getType(), -1); 9387 if (element.hasRequest()) 9388 composeReference(t, "PaymentReconciliation", "request", element.getRequest(), -1); 9389 if (element.hasResponse()) 9390 composeReference(t, "PaymentReconciliation", "response", element.getResponse(), -1); 9391 if (element.hasSubmitter()) 9392 composeReference(t, "PaymentReconciliation", "submitter", element.getSubmitter(), -1); 9393 if (element.hasPayee()) 9394 composeReference(t, "PaymentReconciliation", "payee", element.getPayee(), -1); 9395 if (element.hasDateElement()) 9396 composeDate(t, "PaymentReconciliation", "date", element.getDateElement(), -1); 9397 if (element.hasAmount()) 9398 composeMoney(t, "PaymentReconciliation", "amount", element.getAmount(), -1); 9399 } 9400 9401 protected void composePaymentReconciliationNotesComponent(Complex parent, String parentType, String name, PaymentReconciliation.NotesComponent element, int index) { 9402 if (element == null) 9403 return; 9404 Complex t; 9405 if (Utilities.noString(parentType)) 9406 t = parent; 9407 else { 9408 t = parent.predicate("fhir:"+parentType+'.'+name); 9409 } 9410 composeBackboneElement(t, "processNote", name, element, index); 9411 if (element.hasType()) 9412 composeCodeableConcept(t, "PaymentReconciliation", "type", element.getType(), -1); 9413 if (element.hasTextElement()) 9414 composeString(t, "PaymentReconciliation", "text", element.getTextElement(), -1); 9415 } 9416 9417 protected void composePerson(Complex parent, String parentType, String name, Person element, int index) { 9418 if (element == null) 9419 return; 9420 Complex t; 9421 if (Utilities.noString(parentType)) 9422 t = parent; 9423 else { 9424 t = parent.predicate("fhir:"+parentType+'.'+name); 9425 } 9426 composeDomainResource(t, "Person", name, element, index); 9427 for (int i = 0; i < element.getIdentifier().size(); i++) 9428 composeIdentifier(t, "Person", "identifier", element.getIdentifier().get(i), i); 9429 for (int i = 0; i < element.getName().size(); i++) 9430 composeHumanName(t, "Person", "name", element.getName().get(i), i); 9431 for (int i = 0; i < element.getTelecom().size(); i++) 9432 composeContactPoint(t, "Person", "telecom", element.getTelecom().get(i), i); 9433 if (element.hasGenderElement()) 9434 composeEnum(t, "Person", "gender", element.getGenderElement(), -1); 9435 if (element.hasBirthDateElement()) 9436 composeDate(t, "Person", "birthDate", element.getBirthDateElement(), -1); 9437 for (int i = 0; i < element.getAddress().size(); i++) 9438 composeAddress(t, "Person", "address", element.getAddress().get(i), i); 9439 if (element.hasPhoto()) 9440 composeAttachment(t, "Person", "photo", element.getPhoto(), -1); 9441 if (element.hasManagingOrganization()) 9442 composeReference(t, "Person", "managingOrganization", element.getManagingOrganization(), -1); 9443 if (element.hasActiveElement()) 9444 composeBoolean(t, "Person", "active", element.getActiveElement(), -1); 9445 for (int i = 0; i < element.getLink().size(); i++) 9446 composePersonPersonLinkComponent(t, "Person", "link", element.getLink().get(i), i); 9447 } 9448 9449 protected void composePersonPersonLinkComponent(Complex parent, String parentType, String name, Person.PersonLinkComponent element, int index) { 9450 if (element == null) 9451 return; 9452 Complex t; 9453 if (Utilities.noString(parentType)) 9454 t = parent; 9455 else { 9456 t = parent.predicate("fhir:"+parentType+'.'+name); 9457 } 9458 composeBackboneElement(t, "link", name, element, index); 9459 if (element.hasTarget()) 9460 composeReference(t, "Person", "target", element.getTarget(), -1); 9461 if (element.hasAssuranceElement()) 9462 composeEnum(t, "Person", "assurance", element.getAssuranceElement(), -1); 9463 } 9464 9465 protected void composePlanDefinition(Complex parent, String parentType, String name, PlanDefinition element, int index) { 9466 if (element == null) 9467 return; 9468 Complex t; 9469 if (Utilities.noString(parentType)) 9470 t = parent; 9471 else { 9472 t = parent.predicate("fhir:"+parentType+'.'+name); 9473 } 9474 composeDomainResource(t, "PlanDefinition", name, element, index); 9475 if (element.hasUrlElement()) 9476 composeUri(t, "PlanDefinition", "url", element.getUrlElement(), -1); 9477 for (int i = 0; i < element.getIdentifier().size(); i++) 9478 composeIdentifier(t, "PlanDefinition", "identifier", element.getIdentifier().get(i), i); 9479 if (element.hasVersionElement()) 9480 composeString(t, "PlanDefinition", "version", element.getVersionElement(), -1); 9481 if (element.hasNameElement()) 9482 composeString(t, "PlanDefinition", "name", element.getNameElement(), -1); 9483 if (element.hasTitleElement()) 9484 composeString(t, "PlanDefinition", "title", element.getTitleElement(), -1); 9485 if (element.hasType()) 9486 composeCodeableConcept(t, "PlanDefinition", "type", element.getType(), -1); 9487 if (element.hasStatusElement()) 9488 composeEnum(t, "PlanDefinition", "status", element.getStatusElement(), -1); 9489 if (element.hasExperimentalElement()) 9490 composeBoolean(t, "PlanDefinition", "experimental", element.getExperimentalElement(), -1); 9491 if (element.hasDateElement()) 9492 composeDateTime(t, "PlanDefinition", "date", element.getDateElement(), -1); 9493 if (element.hasPublisherElement()) 9494 composeString(t, "PlanDefinition", "publisher", element.getPublisherElement(), -1); 9495 if (element.hasDescriptionElement()) 9496 composeMarkdown(t, "PlanDefinition", "description", element.getDescriptionElement(), -1); 9497 if (element.hasPurposeElement()) 9498 composeMarkdown(t, "PlanDefinition", "purpose", element.getPurposeElement(), -1); 9499 if (element.hasUsageElement()) 9500 composeString(t, "PlanDefinition", "usage", element.getUsageElement(), -1); 9501 if (element.hasApprovalDateElement()) 9502 composeDate(t, "PlanDefinition", "approvalDate", element.getApprovalDateElement(), -1); 9503 if (element.hasLastReviewDateElement()) 9504 composeDate(t, "PlanDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 9505 if (element.hasEffectivePeriod()) 9506 composePeriod(t, "PlanDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 9507 for (int i = 0; i < element.getUseContext().size(); i++) 9508 composeUsageContext(t, "PlanDefinition", "useContext", element.getUseContext().get(i), i); 9509 for (int i = 0; i < element.getJurisdiction().size(); i++) 9510 composeCodeableConcept(t, "PlanDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 9511 for (int i = 0; i < element.getTopic().size(); i++) 9512 composeCodeableConcept(t, "PlanDefinition", "topic", element.getTopic().get(i), i); 9513 for (int i = 0; i < element.getContributor().size(); i++) 9514 composeContributor(t, "PlanDefinition", "contributor", element.getContributor().get(i), i); 9515 for (int i = 0; i < element.getContact().size(); i++) 9516 composeContactDetail(t, "PlanDefinition", "contact", element.getContact().get(i), i); 9517 if (element.hasCopyrightElement()) 9518 composeMarkdown(t, "PlanDefinition", "copyright", element.getCopyrightElement(), -1); 9519 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 9520 composeRelatedArtifact(t, "PlanDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 9521 for (int i = 0; i < element.getLibrary().size(); i++) 9522 composeReference(t, "PlanDefinition", "library", element.getLibrary().get(i), i); 9523 for (int i = 0; i < element.getGoal().size(); i++) 9524 composePlanDefinitionPlanDefinitionGoalComponent(t, "PlanDefinition", "goal", element.getGoal().get(i), i); 9525 for (int i = 0; i < element.getAction().size(); i++) 9526 composePlanDefinitionPlanDefinitionActionComponent(t, "PlanDefinition", "action", element.getAction().get(i), i); 9527 } 9528 9529 protected void composePlanDefinitionPlanDefinitionGoalComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionGoalComponent element, int index) { 9530 if (element == null) 9531 return; 9532 Complex t; 9533 if (Utilities.noString(parentType)) 9534 t = parent; 9535 else { 9536 t = parent.predicate("fhir:"+parentType+'.'+name); 9537 } 9538 composeBackboneElement(t, "goal", name, element, index); 9539 if (element.hasCategory()) 9540 composeCodeableConcept(t, "PlanDefinition", "category", element.getCategory(), -1); 9541 if (element.hasDescription()) 9542 composeCodeableConcept(t, "PlanDefinition", "description", element.getDescription(), -1); 9543 if (element.hasPriority()) 9544 composeCodeableConcept(t, "PlanDefinition", "priority", element.getPriority(), -1); 9545 if (element.hasStart()) 9546 composeCodeableConcept(t, "PlanDefinition", "start", element.getStart(), -1); 9547 for (int i = 0; i < element.getAddresses().size(); i++) 9548 composeCodeableConcept(t, "PlanDefinition", "addresses", element.getAddresses().get(i), i); 9549 for (int i = 0; i < element.getDocumentation().size(); i++) 9550 composeRelatedArtifact(t, "PlanDefinition", "documentation", element.getDocumentation().get(i), i); 9551 for (int i = 0; i < element.getTarget().size(); i++) 9552 composePlanDefinitionPlanDefinitionGoalTargetComponent(t, "PlanDefinition", "target", element.getTarget().get(i), i); 9553 } 9554 9555 protected void composePlanDefinitionPlanDefinitionGoalTargetComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionGoalTargetComponent element, int index) { 9556 if (element == null) 9557 return; 9558 Complex t; 9559 if (Utilities.noString(parentType)) 9560 t = parent; 9561 else { 9562 t = parent.predicate("fhir:"+parentType+'.'+name); 9563 } 9564 composeBackboneElement(t, "target", name, element, index); 9565 if (element.hasMeasure()) 9566 composeCodeableConcept(t, "PlanDefinition", "measure", element.getMeasure(), -1); 9567 if (element.hasDetail()) 9568 composeType(t, "PlanDefinition", "detail", element.getDetail(), -1); 9569 if (element.hasDue()) 9570 composeDuration(t, "PlanDefinition", "due", element.getDue(), -1); 9571 } 9572 9573 protected void composePlanDefinitionPlanDefinitionActionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionComponent element, int index) { 9574 if (element == null) 9575 return; 9576 Complex t; 9577 if (Utilities.noString(parentType)) 9578 t = parent; 9579 else { 9580 t = parent.predicate("fhir:"+parentType+'.'+name); 9581 } 9582 composeBackboneElement(t, "action", name, element, index); 9583 if (element.hasLabelElement()) 9584 composeString(t, "PlanDefinition", "label", element.getLabelElement(), -1); 9585 if (element.hasTitleElement()) 9586 composeString(t, "PlanDefinition", "title", element.getTitleElement(), -1); 9587 if (element.hasDescriptionElement()) 9588 composeString(t, "PlanDefinition", "description", element.getDescriptionElement(), -1); 9589 if (element.hasTextEquivalentElement()) 9590 composeString(t, "PlanDefinition", "textEquivalent", element.getTextEquivalentElement(), -1); 9591 for (int i = 0; i < element.getCode().size(); i++) 9592 composeCodeableConcept(t, "PlanDefinition", "code", element.getCode().get(i), i); 9593 for (int i = 0; i < element.getReason().size(); i++) 9594 composeCodeableConcept(t, "PlanDefinition", "reason", element.getReason().get(i), i); 9595 for (int i = 0; i < element.getDocumentation().size(); i++) 9596 composeRelatedArtifact(t, "PlanDefinition", "documentation", element.getDocumentation().get(i), i); 9597 for (int i = 0; i < element.getGoalId().size(); i++) 9598 composeId(t, "PlanDefinition", "goalId", element.getGoalId().get(i), i); 9599 for (int i = 0; i < element.getTriggerDefinition().size(); i++) 9600 composeTriggerDefinition(t, "PlanDefinition", "triggerDefinition", element.getTriggerDefinition().get(i), i); 9601 for (int i = 0; i < element.getCondition().size(); i++) 9602 composePlanDefinitionPlanDefinitionActionConditionComponent(t, "PlanDefinition", "condition", element.getCondition().get(i), i); 9603 for (int i = 0; i < element.getInput().size(); i++) 9604 composeDataRequirement(t, "PlanDefinition", "input", element.getInput().get(i), i); 9605 for (int i = 0; i < element.getOutput().size(); i++) 9606 composeDataRequirement(t, "PlanDefinition", "output", element.getOutput().get(i), i); 9607 for (int i = 0; i < element.getRelatedAction().size(); i++) 9608 composePlanDefinitionPlanDefinitionActionRelatedActionComponent(t, "PlanDefinition", "relatedAction", element.getRelatedAction().get(i), i); 9609 if (element.hasTiming()) 9610 composeType(t, "PlanDefinition", "timing", element.getTiming(), -1); 9611 for (int i = 0; i < element.getParticipant().size(); i++) 9612 composePlanDefinitionPlanDefinitionActionParticipantComponent(t, "PlanDefinition", "participant", element.getParticipant().get(i), i); 9613 if (element.hasType()) 9614 composeCoding(t, "PlanDefinition", "type", element.getType(), -1); 9615 if (element.hasGroupingBehaviorElement()) 9616 composeEnum(t, "PlanDefinition", "groupingBehavior", element.getGroupingBehaviorElement(), -1); 9617 if (element.hasSelectionBehaviorElement()) 9618 composeEnum(t, "PlanDefinition", "selectionBehavior", element.getSelectionBehaviorElement(), -1); 9619 if (element.hasRequiredBehaviorElement()) 9620 composeEnum(t, "PlanDefinition", "requiredBehavior", element.getRequiredBehaviorElement(), -1); 9621 if (element.hasPrecheckBehaviorElement()) 9622 composeEnum(t, "PlanDefinition", "precheckBehavior", element.getPrecheckBehaviorElement(), -1); 9623 if (element.hasCardinalityBehaviorElement()) 9624 composeEnum(t, "PlanDefinition", "cardinalityBehavior", element.getCardinalityBehaviorElement(), -1); 9625 if (element.hasDefinition()) 9626 composeReference(t, "PlanDefinition", "definition", element.getDefinition(), -1); 9627 if (element.hasTransform()) 9628 composeReference(t, "PlanDefinition", "transform", element.getTransform(), -1); 9629 for (int i = 0; i < element.getDynamicValue().size(); i++) 9630 composePlanDefinitionPlanDefinitionActionDynamicValueComponent(t, "PlanDefinition", "dynamicValue", element.getDynamicValue().get(i), i); 9631 for (int i = 0; i < element.getAction().size(); i++) 9632 composePlanDefinitionPlanDefinitionActionComponent(t, "PlanDefinition", "action", element.getAction().get(i), i); 9633 } 9634 9635 protected void composePlanDefinitionPlanDefinitionActionConditionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionConditionComponent element, int index) { 9636 if (element == null) 9637 return; 9638 Complex t; 9639 if (Utilities.noString(parentType)) 9640 t = parent; 9641 else { 9642 t = parent.predicate("fhir:"+parentType+'.'+name); 9643 } 9644 composeBackboneElement(t, "condition", name, element, index); 9645 if (element.hasKindElement()) 9646 composeEnum(t, "PlanDefinition", "kind", element.getKindElement(), -1); 9647 if (element.hasDescriptionElement()) 9648 composeString(t, "PlanDefinition", "description", element.getDescriptionElement(), -1); 9649 if (element.hasLanguageElement()) 9650 composeString(t, "PlanDefinition", "language", element.getLanguageElement(), -1); 9651 if (element.hasExpressionElement()) 9652 composeString(t, "PlanDefinition", "expression", element.getExpressionElement(), -1); 9653 } 9654 9655 protected void composePlanDefinitionPlanDefinitionActionRelatedActionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionRelatedActionComponent element, int index) { 9656 if (element == null) 9657 return; 9658 Complex t; 9659 if (Utilities.noString(parentType)) 9660 t = parent; 9661 else { 9662 t = parent.predicate("fhir:"+parentType+'.'+name); 9663 } 9664 composeBackboneElement(t, "relatedAction", name, element, index); 9665 if (element.hasActionIdElement()) 9666 composeId(t, "PlanDefinition", "actionId", element.getActionIdElement(), -1); 9667 if (element.hasRelationshipElement()) 9668 composeEnum(t, "PlanDefinition", "relationship", element.getRelationshipElement(), -1); 9669 if (element.hasOffset()) 9670 composeType(t, "PlanDefinition", "offset", element.getOffset(), -1); 9671 } 9672 9673 protected void composePlanDefinitionPlanDefinitionActionParticipantComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionParticipantComponent element, int index) { 9674 if (element == null) 9675 return; 9676 Complex t; 9677 if (Utilities.noString(parentType)) 9678 t = parent; 9679 else { 9680 t = parent.predicate("fhir:"+parentType+'.'+name); 9681 } 9682 composeBackboneElement(t, "participant", name, element, index); 9683 if (element.hasTypeElement()) 9684 composeEnum(t, "PlanDefinition", "type", element.getTypeElement(), -1); 9685 if (element.hasRole()) 9686 composeCodeableConcept(t, "PlanDefinition", "role", element.getRole(), -1); 9687 } 9688 9689 protected void composePlanDefinitionPlanDefinitionActionDynamicValueComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionDynamicValueComponent element, int index) { 9690 if (element == null) 9691 return; 9692 Complex t; 9693 if (Utilities.noString(parentType)) 9694 t = parent; 9695 else { 9696 t = parent.predicate("fhir:"+parentType+'.'+name); 9697 } 9698 composeBackboneElement(t, "dynamicValue", name, element, index); 9699 if (element.hasDescriptionElement()) 9700 composeString(t, "PlanDefinition", "description", element.getDescriptionElement(), -1); 9701 if (element.hasPathElement()) 9702 composeString(t, "PlanDefinition", "path", element.getPathElement(), -1); 9703 if (element.hasLanguageElement()) 9704 composeString(t, "PlanDefinition", "language", element.getLanguageElement(), -1); 9705 if (element.hasExpressionElement()) 9706 composeString(t, "PlanDefinition", "expression", element.getExpressionElement(), -1); 9707 } 9708 9709 protected void composePractitioner(Complex parent, String parentType, String name, Practitioner element, int index) { 9710 if (element == null) 9711 return; 9712 Complex t; 9713 if (Utilities.noString(parentType)) 9714 t = parent; 9715 else { 9716 t = parent.predicate("fhir:"+parentType+'.'+name); 9717 } 9718 composeDomainResource(t, "Practitioner", name, element, index); 9719 for (int i = 0; i < element.getIdentifier().size(); i++) 9720 composeIdentifier(t, "Practitioner", "identifier", element.getIdentifier().get(i), i); 9721 if (element.hasActiveElement()) 9722 composeBoolean(t, "Practitioner", "active", element.getActiveElement(), -1); 9723 for (int i = 0; i < element.getName().size(); i++) 9724 composeHumanName(t, "Practitioner", "name", element.getName().get(i), i); 9725 for (int i = 0; i < element.getTelecom().size(); i++) 9726 composeContactPoint(t, "Practitioner", "telecom", element.getTelecom().get(i), i); 9727 for (int i = 0; i < element.getAddress().size(); i++) 9728 composeAddress(t, "Practitioner", "address", element.getAddress().get(i), i); 9729 if (element.hasGenderElement()) 9730 composeEnum(t, "Practitioner", "gender", element.getGenderElement(), -1); 9731 if (element.hasBirthDateElement()) 9732 composeDate(t, "Practitioner", "birthDate", element.getBirthDateElement(), -1); 9733 for (int i = 0; i < element.getPhoto().size(); i++) 9734 composeAttachment(t, "Practitioner", "photo", element.getPhoto().get(i), i); 9735 for (int i = 0; i < element.getQualification().size(); i++) 9736 composePractitionerPractitionerQualificationComponent(t, "Practitioner", "qualification", element.getQualification().get(i), i); 9737 for (int i = 0; i < element.getCommunication().size(); i++) 9738 composeCodeableConcept(t, "Practitioner", "communication", element.getCommunication().get(i), i); 9739 } 9740 9741 protected void composePractitionerPractitionerQualificationComponent(Complex parent, String parentType, String name, Practitioner.PractitionerQualificationComponent element, int index) { 9742 if (element == null) 9743 return; 9744 Complex t; 9745 if (Utilities.noString(parentType)) 9746 t = parent; 9747 else { 9748 t = parent.predicate("fhir:"+parentType+'.'+name); 9749 } 9750 composeBackboneElement(t, "qualification", name, element, index); 9751 for (int i = 0; i < element.getIdentifier().size(); i++) 9752 composeIdentifier(t, "Practitioner", "identifier", element.getIdentifier().get(i), i); 9753 if (element.hasCode()) 9754 composeCodeableConcept(t, "Practitioner", "code", element.getCode(), -1); 9755 if (element.hasPeriod()) 9756 composePeriod(t, "Practitioner", "period", element.getPeriod(), -1); 9757 if (element.hasIssuer()) 9758 composeReference(t, "Practitioner", "issuer", element.getIssuer(), -1); 9759 } 9760 9761 protected void composePractitionerRole(Complex parent, String parentType, String name, PractitionerRole element, int index) { 9762 if (element == null) 9763 return; 9764 Complex t; 9765 if (Utilities.noString(parentType)) 9766 t = parent; 9767 else { 9768 t = parent.predicate("fhir:"+parentType+'.'+name); 9769 } 9770 composeDomainResource(t, "PractitionerRole", name, element, index); 9771 for (int i = 0; i < element.getIdentifier().size(); i++) 9772 composeIdentifier(t, "PractitionerRole", "identifier", element.getIdentifier().get(i), i); 9773 if (element.hasActiveElement()) 9774 composeBoolean(t, "PractitionerRole", "active", element.getActiveElement(), -1); 9775 if (element.hasPeriod()) 9776 composePeriod(t, "PractitionerRole", "period", element.getPeriod(), -1); 9777 if (element.hasPractitioner()) 9778 composeReference(t, "PractitionerRole", "practitioner", element.getPractitioner(), -1); 9779 if (element.hasOrganization()) 9780 composeReference(t, "PractitionerRole", "organization", element.getOrganization(), -1); 9781 for (int i = 0; i < element.getCode().size(); i++) 9782 composeCodeableConcept(t, "PractitionerRole", "code", element.getCode().get(i), i); 9783 for (int i = 0; i < element.getSpecialty().size(); i++) 9784 composeCodeableConcept(t, "PractitionerRole", "specialty", element.getSpecialty().get(i), i); 9785 for (int i = 0; i < element.getLocation().size(); i++) 9786 composeReference(t, "PractitionerRole", "location", element.getLocation().get(i), i); 9787 for (int i = 0; i < element.getHealthcareService().size(); i++) 9788 composeReference(t, "PractitionerRole", "healthcareService", element.getHealthcareService().get(i), i); 9789 for (int i = 0; i < element.getTelecom().size(); i++) 9790 composeContactPoint(t, "PractitionerRole", "telecom", element.getTelecom().get(i), i); 9791 for (int i = 0; i < element.getAvailableTime().size(); i++) 9792 composePractitionerRolePractitionerRoleAvailableTimeComponent(t, "PractitionerRole", "availableTime", element.getAvailableTime().get(i), i); 9793 for (int i = 0; i < element.getNotAvailable().size(); i++) 9794 composePractitionerRolePractitionerRoleNotAvailableComponent(t, "PractitionerRole", "notAvailable", element.getNotAvailable().get(i), i); 9795 if (element.hasAvailabilityExceptionsElement()) 9796 composeString(t, "PractitionerRole", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1); 9797 for (int i = 0; i < element.getEndpoint().size(); i++) 9798 composeReference(t, "PractitionerRole", "endpoint", element.getEndpoint().get(i), i); 9799 } 9800 9801 protected void composePractitionerRolePractitionerRoleAvailableTimeComponent(Complex parent, String parentType, String name, PractitionerRole.PractitionerRoleAvailableTimeComponent element, int index) { 9802 if (element == null) 9803 return; 9804 Complex t; 9805 if (Utilities.noString(parentType)) 9806 t = parent; 9807 else { 9808 t = parent.predicate("fhir:"+parentType+'.'+name); 9809 } 9810 composeBackboneElement(t, "availableTime", name, element, index); 9811 for (int i = 0; i < element.getDaysOfWeek().size(); i++) 9812 composeEnum(t, "PractitionerRole", "daysOfWeek", element.getDaysOfWeek().get(i), i); 9813 if (element.hasAllDayElement()) 9814 composeBoolean(t, "PractitionerRole", "allDay", element.getAllDayElement(), -1); 9815 if (element.hasAvailableStartTimeElement()) 9816 composeTime(t, "PractitionerRole", "availableStartTime", element.getAvailableStartTimeElement(), -1); 9817 if (element.hasAvailableEndTimeElement()) 9818 composeTime(t, "PractitionerRole", "availableEndTime", element.getAvailableEndTimeElement(), -1); 9819 } 9820 9821 protected void composePractitionerRolePractitionerRoleNotAvailableComponent(Complex parent, String parentType, String name, PractitionerRole.PractitionerRoleNotAvailableComponent element, int index) { 9822 if (element == null) 9823 return; 9824 Complex t; 9825 if (Utilities.noString(parentType)) 9826 t = parent; 9827 else { 9828 t = parent.predicate("fhir:"+parentType+'.'+name); 9829 } 9830 composeBackboneElement(t, "notAvailable", name, element, index); 9831 if (element.hasDescriptionElement()) 9832 composeString(t, "PractitionerRole", "description", element.getDescriptionElement(), -1); 9833 if (element.hasDuring()) 9834 composePeriod(t, "PractitionerRole", "during", element.getDuring(), -1); 9835 } 9836 9837 protected void composeProcedure(Complex parent, String parentType, String name, Procedure element, int index) { 9838 if (element == null) 9839 return; 9840 Complex t; 9841 if (Utilities.noString(parentType)) 9842 t = parent; 9843 else { 9844 t = parent.predicate("fhir:"+parentType+'.'+name); 9845 } 9846 composeDomainResource(t, "Procedure", name, element, index); 9847 for (int i = 0; i < element.getIdentifier().size(); i++) 9848 composeIdentifier(t, "Procedure", "identifier", element.getIdentifier().get(i), i); 9849 for (int i = 0; i < element.getDefinition().size(); i++) 9850 composeReference(t, "Procedure", "definition", element.getDefinition().get(i), i); 9851 for (int i = 0; i < element.getBasedOn().size(); i++) 9852 composeReference(t, "Procedure", "basedOn", element.getBasedOn().get(i), i); 9853 for (int i = 0; i < element.getPartOf().size(); i++) 9854 composeReference(t, "Procedure", "partOf", element.getPartOf().get(i), i); 9855 if (element.hasStatusElement()) 9856 composeEnum(t, "Procedure", "status", element.getStatusElement(), -1); 9857 if (element.hasNotDoneElement()) 9858 composeBoolean(t, "Procedure", "notDone", element.getNotDoneElement(), -1); 9859 if (element.hasNotDoneReason()) 9860 composeCodeableConcept(t, "Procedure", "notDoneReason", element.getNotDoneReason(), -1); 9861 if (element.hasCategory()) 9862 composeCodeableConcept(t, "Procedure", "category", element.getCategory(), -1); 9863 if (element.hasCode()) 9864 composeCodeableConcept(t, "Procedure", "code", element.getCode(), -1); 9865 if (element.hasSubject()) 9866 composeReference(t, "Procedure", "subject", element.getSubject(), -1); 9867 if (element.hasContext()) 9868 composeReference(t, "Procedure", "context", element.getContext(), -1); 9869 if (element.hasPerformed()) 9870 composeType(t, "Procedure", "performed", element.getPerformed(), -1); 9871 for (int i = 0; i < element.getPerformer().size(); i++) 9872 composeProcedureProcedurePerformerComponent(t, "Procedure", "performer", element.getPerformer().get(i), i); 9873 if (element.hasLocation()) 9874 composeReference(t, "Procedure", "location", element.getLocation(), -1); 9875 for (int i = 0; i < element.getReasonCode().size(); i++) 9876 composeCodeableConcept(t, "Procedure", "reasonCode", element.getReasonCode().get(i), i); 9877 for (int i = 0; i < element.getReasonReference().size(); i++) 9878 composeReference(t, "Procedure", "reasonReference", element.getReasonReference().get(i), i); 9879 for (int i = 0; i < element.getBodySite().size(); i++) 9880 composeCodeableConcept(t, "Procedure", "bodySite", element.getBodySite().get(i), i); 9881 if (element.hasOutcome()) 9882 composeCodeableConcept(t, "Procedure", "outcome", element.getOutcome(), -1); 9883 for (int i = 0; i < element.getReport().size(); i++) 9884 composeReference(t, "Procedure", "report", element.getReport().get(i), i); 9885 for (int i = 0; i < element.getComplication().size(); i++) 9886 composeCodeableConcept(t, "Procedure", "complication", element.getComplication().get(i), i); 9887 for (int i = 0; i < element.getComplicationDetail().size(); i++) 9888 composeReference(t, "Procedure", "complicationDetail", element.getComplicationDetail().get(i), i); 9889 for (int i = 0; i < element.getFollowUp().size(); i++) 9890 composeCodeableConcept(t, "Procedure", "followUp", element.getFollowUp().get(i), i); 9891 for (int i = 0; i < element.getNote().size(); i++) 9892 composeAnnotation(t, "Procedure", "note", element.getNote().get(i), i); 9893 for (int i = 0; i < element.getFocalDevice().size(); i++) 9894 composeProcedureProcedureFocalDeviceComponent(t, "Procedure", "focalDevice", element.getFocalDevice().get(i), i); 9895 for (int i = 0; i < element.getUsedReference().size(); i++) 9896 composeReference(t, "Procedure", "usedReference", element.getUsedReference().get(i), i); 9897 for (int i = 0; i < element.getUsedCode().size(); i++) 9898 composeCodeableConcept(t, "Procedure", "usedCode", element.getUsedCode().get(i), i); 9899 } 9900 9901 protected void composeProcedureProcedurePerformerComponent(Complex parent, String parentType, String name, Procedure.ProcedurePerformerComponent element, int index) { 9902 if (element == null) 9903 return; 9904 Complex t; 9905 if (Utilities.noString(parentType)) 9906 t = parent; 9907 else { 9908 t = parent.predicate("fhir:"+parentType+'.'+name); 9909 } 9910 composeBackboneElement(t, "performer", name, element, index); 9911 if (element.hasRole()) 9912 composeCodeableConcept(t, "Procedure", "role", element.getRole(), -1); 9913 if (element.hasActor()) 9914 composeReference(t, "Procedure", "actor", element.getActor(), -1); 9915 if (element.hasOnBehalfOf()) 9916 composeReference(t, "Procedure", "onBehalfOf", element.getOnBehalfOf(), -1); 9917 } 9918 9919 protected void composeProcedureProcedureFocalDeviceComponent(Complex parent, String parentType, String name, Procedure.ProcedureFocalDeviceComponent element, int index) { 9920 if (element == null) 9921 return; 9922 Complex t; 9923 if (Utilities.noString(parentType)) 9924 t = parent; 9925 else { 9926 t = parent.predicate("fhir:"+parentType+'.'+name); 9927 } 9928 composeBackboneElement(t, "focalDevice", name, element, index); 9929 if (element.hasAction()) 9930 composeCodeableConcept(t, "Procedure", "action", element.getAction(), -1); 9931 if (element.hasManipulated()) 9932 composeReference(t, "Procedure", "manipulated", element.getManipulated(), -1); 9933 } 9934 9935 protected void composeProcedureRequest(Complex parent, String parentType, String name, ProcedureRequest element, int index) { 9936 if (element == null) 9937 return; 9938 Complex t; 9939 if (Utilities.noString(parentType)) 9940 t = parent; 9941 else { 9942 t = parent.predicate("fhir:"+parentType+'.'+name); 9943 } 9944 composeDomainResource(t, "ProcedureRequest", name, element, index); 9945 for (int i = 0; i < element.getIdentifier().size(); i++) 9946 composeIdentifier(t, "ProcedureRequest", "identifier", element.getIdentifier().get(i), i); 9947 for (int i = 0; i < element.getDefinition().size(); i++) 9948 composeReference(t, "ProcedureRequest", "definition", element.getDefinition().get(i), i); 9949 for (int i = 0; i < element.getBasedOn().size(); i++) 9950 composeReference(t, "ProcedureRequest", "basedOn", element.getBasedOn().get(i), i); 9951 for (int i = 0; i < element.getReplaces().size(); i++) 9952 composeReference(t, "ProcedureRequest", "replaces", element.getReplaces().get(i), i); 9953 if (element.hasRequisition()) 9954 composeIdentifier(t, "ProcedureRequest", "requisition", element.getRequisition(), -1); 9955 if (element.hasStatusElement()) 9956 composeEnum(t, "ProcedureRequest", "status", element.getStatusElement(), -1); 9957 if (element.hasIntentElement()) 9958 composeEnum(t, "ProcedureRequest", "intent", element.getIntentElement(), -1); 9959 if (element.hasPriorityElement()) 9960 composeEnum(t, "ProcedureRequest", "priority", element.getPriorityElement(), -1); 9961 if (element.hasDoNotPerformElement()) 9962 composeBoolean(t, "ProcedureRequest", "doNotPerform", element.getDoNotPerformElement(), -1); 9963 for (int i = 0; i < element.getCategory().size(); i++) 9964 composeCodeableConcept(t, "ProcedureRequest", "category", element.getCategory().get(i), i); 9965 if (element.hasCode()) 9966 composeCodeableConcept(t, "ProcedureRequest", "code", element.getCode(), -1); 9967 if (element.hasSubject()) 9968 composeReference(t, "ProcedureRequest", "subject", element.getSubject(), -1); 9969 if (element.hasContext()) 9970 composeReference(t, "ProcedureRequest", "context", element.getContext(), -1); 9971 if (element.hasOccurrence()) 9972 composeType(t, "ProcedureRequest", "occurrence", element.getOccurrence(), -1); 9973 if (element.hasAsNeeded()) 9974 composeType(t, "ProcedureRequest", "asNeeded", element.getAsNeeded(), -1); 9975 if (element.hasAuthoredOnElement()) 9976 composeDateTime(t, "ProcedureRequest", "authoredOn", element.getAuthoredOnElement(), -1); 9977 if (element.hasRequester()) 9978 composeProcedureRequestProcedureRequestRequesterComponent(t, "ProcedureRequest", "requester", element.getRequester(), -1); 9979 if (element.hasPerformerType()) 9980 composeCodeableConcept(t, "ProcedureRequest", "performerType", element.getPerformerType(), -1); 9981 if (element.hasPerformer()) 9982 composeReference(t, "ProcedureRequest", "performer", element.getPerformer(), -1); 9983 for (int i = 0; i < element.getReasonCode().size(); i++) 9984 composeCodeableConcept(t, "ProcedureRequest", "reasonCode", element.getReasonCode().get(i), i); 9985 for (int i = 0; i < element.getReasonReference().size(); i++) 9986 composeReference(t, "ProcedureRequest", "reasonReference", element.getReasonReference().get(i), i); 9987 for (int i = 0; i < element.getSupportingInfo().size(); i++) 9988 composeReference(t, "ProcedureRequest", "supportingInfo", element.getSupportingInfo().get(i), i); 9989 for (int i = 0; i < element.getSpecimen().size(); i++) 9990 composeReference(t, "ProcedureRequest", "specimen", element.getSpecimen().get(i), i); 9991 for (int i = 0; i < element.getBodySite().size(); i++) 9992 composeCodeableConcept(t, "ProcedureRequest", "bodySite", element.getBodySite().get(i), i); 9993 for (int i = 0; i < element.getNote().size(); i++) 9994 composeAnnotation(t, "ProcedureRequest", "note", element.getNote().get(i), i); 9995 for (int i = 0; i < element.getRelevantHistory().size(); i++) 9996 composeReference(t, "ProcedureRequest", "relevantHistory", element.getRelevantHistory().get(i), i); 9997 } 9998 9999 protected void composeProcedureRequestProcedureRequestRequesterComponent(Complex parent, String parentType, String name, ProcedureRequest.ProcedureRequestRequesterComponent element, int index) { 10000 if (element == null) 10001 return; 10002 Complex t; 10003 if (Utilities.noString(parentType)) 10004 t = parent; 10005 else { 10006 t = parent.predicate("fhir:"+parentType+'.'+name); 10007 } 10008 composeBackboneElement(t, "requester", name, element, index); 10009 if (element.hasAgent()) 10010 composeReference(t, "ProcedureRequest", "agent", element.getAgent(), -1); 10011 if (element.hasOnBehalfOf()) 10012 composeReference(t, "ProcedureRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 10013 } 10014 10015 protected void composeProcessRequest(Complex parent, String parentType, String name, ProcessRequest element, int index) { 10016 if (element == null) 10017 return; 10018 Complex t; 10019 if (Utilities.noString(parentType)) 10020 t = parent; 10021 else { 10022 t = parent.predicate("fhir:"+parentType+'.'+name); 10023 } 10024 composeDomainResource(t, "ProcessRequest", name, element, index); 10025 for (int i = 0; i < element.getIdentifier().size(); i++) 10026 composeIdentifier(t, "ProcessRequest", "identifier", element.getIdentifier().get(i), i); 10027 if (element.hasStatusElement()) 10028 composeEnum(t, "ProcessRequest", "status", element.getStatusElement(), -1); 10029 if (element.hasActionElement()) 10030 composeEnum(t, "ProcessRequest", "action", element.getActionElement(), -1); 10031 if (element.hasTarget()) 10032 composeReference(t, "ProcessRequest", "target", element.getTarget(), -1); 10033 if (element.hasCreatedElement()) 10034 composeDateTime(t, "ProcessRequest", "created", element.getCreatedElement(), -1); 10035 if (element.hasProvider()) 10036 composeReference(t, "ProcessRequest", "provider", element.getProvider(), -1); 10037 if (element.hasOrganization()) 10038 composeReference(t, "ProcessRequest", "organization", element.getOrganization(), -1); 10039 if (element.hasRequest()) 10040 composeReference(t, "ProcessRequest", "request", element.getRequest(), -1); 10041 if (element.hasResponse()) 10042 composeReference(t, "ProcessRequest", "response", element.getResponse(), -1); 10043 if (element.hasNullifyElement()) 10044 composeBoolean(t, "ProcessRequest", "nullify", element.getNullifyElement(), -1); 10045 if (element.hasReferenceElement()) 10046 composeString(t, "ProcessRequest", "reference", element.getReferenceElement(), -1); 10047 for (int i = 0; i < element.getItem().size(); i++) 10048 composeProcessRequestItemsComponent(t, "ProcessRequest", "item", element.getItem().get(i), i); 10049 for (int i = 0; i < element.getInclude().size(); i++) 10050 composeString(t, "ProcessRequest", "include", element.getInclude().get(i), i); 10051 for (int i = 0; i < element.getExclude().size(); i++) 10052 composeString(t, "ProcessRequest", "exclude", element.getExclude().get(i), i); 10053 if (element.hasPeriod()) 10054 composePeriod(t, "ProcessRequest", "period", element.getPeriod(), -1); 10055 } 10056 10057 protected void composeProcessRequestItemsComponent(Complex parent, String parentType, String name, ProcessRequest.ItemsComponent element, int index) { 10058 if (element == null) 10059 return; 10060 Complex t; 10061 if (Utilities.noString(parentType)) 10062 t = parent; 10063 else { 10064 t = parent.predicate("fhir:"+parentType+'.'+name); 10065 } 10066 composeBackboneElement(t, "item", name, element, index); 10067 if (element.hasSequenceLinkIdElement()) 10068 composeInteger(t, "ProcessRequest", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 10069 } 10070 10071 protected void composeProcessResponse(Complex parent, String parentType, String name, ProcessResponse element, int index) { 10072 if (element == null) 10073 return; 10074 Complex t; 10075 if (Utilities.noString(parentType)) 10076 t = parent; 10077 else { 10078 t = parent.predicate("fhir:"+parentType+'.'+name); 10079 } 10080 composeDomainResource(t, "ProcessResponse", name, element, index); 10081 for (int i = 0; i < element.getIdentifier().size(); i++) 10082 composeIdentifier(t, "ProcessResponse", "identifier", element.getIdentifier().get(i), i); 10083 if (element.hasStatusElement()) 10084 composeEnum(t, "ProcessResponse", "status", element.getStatusElement(), -1); 10085 if (element.hasCreatedElement()) 10086 composeDateTime(t, "ProcessResponse", "created", element.getCreatedElement(), -1); 10087 if (element.hasOrganization()) 10088 composeReference(t, "ProcessResponse", "organization", element.getOrganization(), -1); 10089 if (element.hasRequest()) 10090 composeReference(t, "ProcessResponse", "request", element.getRequest(), -1); 10091 if (element.hasOutcome()) 10092 composeCodeableConcept(t, "ProcessResponse", "outcome", element.getOutcome(), -1); 10093 if (element.hasDispositionElement()) 10094 composeString(t, "ProcessResponse", "disposition", element.getDispositionElement(), -1); 10095 if (element.hasRequestProvider()) 10096 composeReference(t, "ProcessResponse", "requestProvider", element.getRequestProvider(), -1); 10097 if (element.hasRequestOrganization()) 10098 composeReference(t, "ProcessResponse", "requestOrganization", element.getRequestOrganization(), -1); 10099 if (element.hasForm()) 10100 composeCodeableConcept(t, "ProcessResponse", "form", element.getForm(), -1); 10101 for (int i = 0; i < element.getProcessNote().size(); i++) 10102 composeProcessResponseProcessResponseProcessNoteComponent(t, "ProcessResponse", "processNote", element.getProcessNote().get(i), i); 10103 for (int i = 0; i < element.getError().size(); i++) 10104 composeCodeableConcept(t, "ProcessResponse", "error", element.getError().get(i), i); 10105 for (int i = 0; i < element.getCommunicationRequest().size(); i++) 10106 composeReference(t, "ProcessResponse", "communicationRequest", element.getCommunicationRequest().get(i), i); 10107 } 10108 10109 protected void composeProcessResponseProcessResponseProcessNoteComponent(Complex parent, String parentType, String name, ProcessResponse.ProcessResponseProcessNoteComponent element, int index) { 10110 if (element == null) 10111 return; 10112 Complex t; 10113 if (Utilities.noString(parentType)) 10114 t = parent; 10115 else { 10116 t = parent.predicate("fhir:"+parentType+'.'+name); 10117 } 10118 composeBackboneElement(t, "processNote", name, element, index); 10119 if (element.hasType()) 10120 composeCodeableConcept(t, "ProcessResponse", "type", element.getType(), -1); 10121 if (element.hasTextElement()) 10122 composeString(t, "ProcessResponse", "text", element.getTextElement(), -1); 10123 } 10124 10125 protected void composeProvenance(Complex parent, String parentType, String name, Provenance element, int index) { 10126 if (element == null) 10127 return; 10128 Complex t; 10129 if (Utilities.noString(parentType)) 10130 t = parent; 10131 else { 10132 t = parent.predicate("fhir:"+parentType+'.'+name); 10133 } 10134 composeDomainResource(t, "Provenance", name, element, index); 10135 for (int i = 0; i < element.getTarget().size(); i++) 10136 composeReference(t, "Provenance", "target", element.getTarget().get(i), i); 10137 if (element.hasPeriod()) 10138 composePeriod(t, "Provenance", "period", element.getPeriod(), -1); 10139 if (element.hasRecordedElement()) 10140 composeInstant(t, "Provenance", "recorded", element.getRecordedElement(), -1); 10141 for (int i = 0; i < element.getPolicy().size(); i++) 10142 composeUri(t, "Provenance", "policy", element.getPolicy().get(i), i); 10143 if (element.hasLocation()) 10144 composeReference(t, "Provenance", "location", element.getLocation(), -1); 10145 for (int i = 0; i < element.getReason().size(); i++) 10146 composeCoding(t, "Provenance", "reason", element.getReason().get(i), i); 10147 if (element.hasActivity()) 10148 composeCoding(t, "Provenance", "activity", element.getActivity(), -1); 10149 for (int i = 0; i < element.getAgent().size(); i++) 10150 composeProvenanceProvenanceAgentComponent(t, "Provenance", "agent", element.getAgent().get(i), i); 10151 for (int i = 0; i < element.getEntity().size(); i++) 10152 composeProvenanceProvenanceEntityComponent(t, "Provenance", "entity", element.getEntity().get(i), i); 10153 for (int i = 0; i < element.getSignature().size(); i++) 10154 composeSignature(t, "Provenance", "signature", element.getSignature().get(i), i); 10155 } 10156 10157 protected void composeProvenanceProvenanceAgentComponent(Complex parent, String parentType, String name, Provenance.ProvenanceAgentComponent element, int index) { 10158 if (element == null) 10159 return; 10160 Complex t; 10161 if (Utilities.noString(parentType)) 10162 t = parent; 10163 else { 10164 t = parent.predicate("fhir:"+parentType+'.'+name); 10165 } 10166 composeBackboneElement(t, "agent", name, element, index); 10167 for (int i = 0; i < element.getRole().size(); i++) 10168 composeCodeableConcept(t, "Provenance", "role", element.getRole().get(i), i); 10169 if (element.hasWho()) 10170 composeType(t, "Provenance", "who", element.getWho(), -1); 10171 if (element.hasOnBehalfOf()) 10172 composeType(t, "Provenance", "onBehalfOf", element.getOnBehalfOf(), -1); 10173 if (element.hasRelatedAgentType()) 10174 composeCodeableConcept(t, "Provenance", "relatedAgentType", element.getRelatedAgentType(), -1); 10175 } 10176 10177 protected void composeProvenanceProvenanceEntityComponent(Complex parent, String parentType, String name, Provenance.ProvenanceEntityComponent element, int index) { 10178 if (element == null) 10179 return; 10180 Complex t; 10181 if (Utilities.noString(parentType)) 10182 t = parent; 10183 else { 10184 t = parent.predicate("fhir:"+parentType+'.'+name); 10185 } 10186 composeBackboneElement(t, "entity", name, element, index); 10187 if (element.hasRoleElement()) 10188 composeEnum(t, "Provenance", "role", element.getRoleElement(), -1); 10189 if (element.hasWhat()) 10190 composeType(t, "Provenance", "what", element.getWhat(), -1); 10191 for (int i = 0; i < element.getAgent().size(); i++) 10192 composeProvenanceProvenanceAgentComponent(t, "Provenance", "agent", element.getAgent().get(i), i); 10193 } 10194 10195 protected void composeQuestionnaire(Complex parent, String parentType, String name, Questionnaire element, int index) { 10196 if (element == null) 10197 return; 10198 Complex t; 10199 if (Utilities.noString(parentType)) 10200 t = parent; 10201 else { 10202 t = parent.predicate("fhir:"+parentType+'.'+name); 10203 } 10204 composeDomainResource(t, "Questionnaire", name, element, index); 10205 if (element.hasUrlElement()) 10206 composeUri(t, "Questionnaire", "url", element.getUrlElement(), -1); 10207 for (int i = 0; i < element.getIdentifier().size(); i++) 10208 composeIdentifier(t, "Questionnaire", "identifier", element.getIdentifier().get(i), i); 10209 if (element.hasVersionElement()) 10210 composeString(t, "Questionnaire", "version", element.getVersionElement(), -1); 10211 if (element.hasNameElement()) 10212 composeString(t, "Questionnaire", "name", element.getNameElement(), -1); 10213 if (element.hasTitleElement()) 10214 composeString(t, "Questionnaire", "title", element.getTitleElement(), -1); 10215 if (element.hasStatusElement()) 10216 composeEnum(t, "Questionnaire", "status", element.getStatusElement(), -1); 10217 if (element.hasExperimentalElement()) 10218 composeBoolean(t, "Questionnaire", "experimental", element.getExperimentalElement(), -1); 10219 if (element.hasDateElement()) 10220 composeDateTime(t, "Questionnaire", "date", element.getDateElement(), -1); 10221 if (element.hasPublisherElement()) 10222 composeString(t, "Questionnaire", "publisher", element.getPublisherElement(), -1); 10223 if (element.hasDescriptionElement()) 10224 composeMarkdown(t, "Questionnaire", "description", element.getDescriptionElement(), -1); 10225 if (element.hasPurposeElement()) 10226 composeMarkdown(t, "Questionnaire", "purpose", element.getPurposeElement(), -1); 10227 if (element.hasApprovalDateElement()) 10228 composeDate(t, "Questionnaire", "approvalDate", element.getApprovalDateElement(), -1); 10229 if (element.hasLastReviewDateElement()) 10230 composeDate(t, "Questionnaire", "lastReviewDate", element.getLastReviewDateElement(), -1); 10231 if (element.hasEffectivePeriod()) 10232 composePeriod(t, "Questionnaire", "effectivePeriod", element.getEffectivePeriod(), -1); 10233 for (int i = 0; i < element.getUseContext().size(); i++) 10234 composeUsageContext(t, "Questionnaire", "useContext", element.getUseContext().get(i), i); 10235 for (int i = 0; i < element.getJurisdiction().size(); i++) 10236 composeCodeableConcept(t, "Questionnaire", "jurisdiction", element.getJurisdiction().get(i), i); 10237 for (int i = 0; i < element.getContact().size(); i++) 10238 composeContactDetail(t, "Questionnaire", "contact", element.getContact().get(i), i); 10239 if (element.hasCopyrightElement()) 10240 composeMarkdown(t, "Questionnaire", "copyright", element.getCopyrightElement(), -1); 10241 for (int i = 0; i < element.getCode().size(); i++) 10242 composeCoding(t, "Questionnaire", "code", element.getCode().get(i), i); 10243 for (int i = 0; i < element.getSubjectType().size(); i++) 10244 composeCode(t, "Questionnaire", "subjectType", element.getSubjectType().get(i), i); 10245 for (int i = 0; i < element.getItem().size(); i++) 10246 composeQuestionnaireQuestionnaireItemComponent(t, "Questionnaire", "item", element.getItem().get(i), i); 10247 } 10248 10249 protected void composeQuestionnaireQuestionnaireItemComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemComponent element, int index) { 10250 if (element == null) 10251 return; 10252 Complex t; 10253 if (Utilities.noString(parentType)) 10254 t = parent; 10255 else { 10256 t = parent.predicate("fhir:"+parentType+'.'+name); 10257 } 10258 composeBackboneElement(t, "item", name, element, index); 10259 if (element.hasLinkIdElement()) 10260 composeString(t, "Questionnaire", "linkId", element.getLinkIdElement(), -1); 10261 if (element.hasDefinitionElement()) 10262 composeUri(t, "Questionnaire", "definition", element.getDefinitionElement(), -1); 10263 for (int i = 0; i < element.getCode().size(); i++) 10264 composeCoding(t, "Questionnaire", "code", element.getCode().get(i), i); 10265 if (element.hasPrefixElement()) 10266 composeString(t, "Questionnaire", "prefix", element.getPrefixElement(), -1); 10267 if (element.hasTextElement()) 10268 composeString(t, "Questionnaire", "text", element.getTextElement(), -1); 10269 if (element.hasTypeElement()) 10270 composeEnum(t, "Questionnaire", "type", element.getTypeElement(), -1); 10271 for (int i = 0; i < element.getEnableWhen().size(); i++) 10272 composeQuestionnaireQuestionnaireItemEnableWhenComponent(t, "Questionnaire", "enableWhen", element.getEnableWhen().get(i), i); 10273 if (element.hasRequiredElement()) 10274 composeBoolean(t, "Questionnaire", "required", element.getRequiredElement(), -1); 10275 if (element.hasRepeatsElement()) 10276 composeBoolean(t, "Questionnaire", "repeats", element.getRepeatsElement(), -1); 10277 if (element.hasReadOnlyElement()) 10278 composeBoolean(t, "Questionnaire", "readOnly", element.getReadOnlyElement(), -1); 10279 if (element.hasMaxLengthElement()) 10280 composeInteger(t, "Questionnaire", "maxLength", element.getMaxLengthElement(), -1); 10281 if (element.hasOptions()) 10282 composeReference(t, "Questionnaire", "options", element.getOptions(), -1); 10283 for (int i = 0; i < element.getOption().size(); i++) 10284 composeQuestionnaireQuestionnaireItemOptionComponent(t, "Questionnaire", "option", element.getOption().get(i), i); 10285 if (element.hasInitial()) 10286 composeType(t, "Questionnaire", "initial", element.getInitial(), -1); 10287 for (int i = 0; i < element.getItem().size(); i++) 10288 composeQuestionnaireQuestionnaireItemComponent(t, "Questionnaire", "item", element.getItem().get(i), i); 10289 } 10290 10291 protected void composeQuestionnaireQuestionnaireItemEnableWhenComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemEnableWhenComponent element, int index) { 10292 if (element == null) 10293 return; 10294 Complex t; 10295 if (Utilities.noString(parentType)) 10296 t = parent; 10297 else { 10298 t = parent.predicate("fhir:"+parentType+'.'+name); 10299 } 10300 composeBackboneElement(t, "enableWhen", name, element, index); 10301 if (element.hasQuestionElement()) 10302 composeString(t, "Questionnaire", "question", element.getQuestionElement(), -1); 10303 if (element.hasHasAnswerElement()) 10304 composeBoolean(t, "Questionnaire", "hasAnswer", element.getHasAnswerElement(), -1); 10305 if (element.hasAnswer()) 10306 composeType(t, "Questionnaire", "answer", element.getAnswer(), -1); 10307 } 10308 10309 protected void composeQuestionnaireQuestionnaireItemOptionComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemOptionComponent element, int index) { 10310 if (element == null) 10311 return; 10312 Complex t; 10313 if (Utilities.noString(parentType)) 10314 t = parent; 10315 else { 10316 t = parent.predicate("fhir:"+parentType+'.'+name); 10317 } 10318 composeBackboneElement(t, "option", name, element, index); 10319 if (element.hasValue()) 10320 composeType(t, "Questionnaire", "value", element.getValue(), -1); 10321 } 10322 10323 protected void composeQuestionnaireResponse(Complex parent, String parentType, String name, QuestionnaireResponse element, int index) { 10324 if (element == null) 10325 return; 10326 Complex t; 10327 if (Utilities.noString(parentType)) 10328 t = parent; 10329 else { 10330 t = parent.predicate("fhir:"+parentType+'.'+name); 10331 } 10332 composeDomainResource(t, "QuestionnaireResponse", name, element, index); 10333 if (element.hasIdentifier()) 10334 composeIdentifier(t, "QuestionnaireResponse", "identifier", element.getIdentifier(), -1); 10335 for (int i = 0; i < element.getBasedOn().size(); i++) 10336 composeReference(t, "QuestionnaireResponse", "basedOn", element.getBasedOn().get(i), i); 10337 for (int i = 0; i < element.getParent().size(); i++) 10338 composeReference(t, "QuestionnaireResponse", "parent", element.getParent().get(i), i); 10339 if (element.hasQuestionnaire()) 10340 composeReference(t, "QuestionnaireResponse", "questionnaire", element.getQuestionnaire(), -1); 10341 if (element.hasStatusElement()) 10342 composeEnum(t, "QuestionnaireResponse", "status", element.getStatusElement(), -1); 10343 if (element.hasSubject()) 10344 composeReference(t, "QuestionnaireResponse", "subject", element.getSubject(), -1); 10345 if (element.hasContext()) 10346 composeReference(t, "QuestionnaireResponse", "context", element.getContext(), -1); 10347 if (element.hasAuthoredElement()) 10348 composeDateTime(t, "QuestionnaireResponse", "authored", element.getAuthoredElement(), -1); 10349 if (element.hasAuthor()) 10350 composeReference(t, "QuestionnaireResponse", "author", element.getAuthor(), -1); 10351 if (element.hasSource()) 10352 composeReference(t, "QuestionnaireResponse", "source", element.getSource(), -1); 10353 for (int i = 0; i < element.getItem().size(); i++) 10354 composeQuestionnaireResponseQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i); 10355 } 10356 10357 protected void composeQuestionnaireResponseQuestionnaireResponseItemComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemComponent element, int index) { 10358 if (element == null) 10359 return; 10360 Complex t; 10361 if (Utilities.noString(parentType)) 10362 t = parent; 10363 else { 10364 t = parent.predicate("fhir:"+parentType+'.'+name); 10365 } 10366 composeBackboneElement(t, "item", name, element, index); 10367 if (element.hasLinkIdElement()) 10368 composeString(t, "QuestionnaireResponse", "linkId", element.getLinkIdElement(), -1); 10369 if (element.hasDefinitionElement()) 10370 composeUri(t, "QuestionnaireResponse", "definition", element.getDefinitionElement(), -1); 10371 if (element.hasTextElement()) 10372 composeString(t, "QuestionnaireResponse", "text", element.getTextElement(), -1); 10373 if (element.hasSubject()) 10374 composeReference(t, "QuestionnaireResponse", "subject", element.getSubject(), -1); 10375 for (int i = 0; i < element.getAnswer().size(); i++) 10376 composeQuestionnaireResponseQuestionnaireResponseItemAnswerComponent(t, "QuestionnaireResponse", "answer", element.getAnswer().get(i), i); 10377 for (int i = 0; i < element.getItem().size(); i++) 10378 composeQuestionnaireResponseQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i); 10379 } 10380 10381 protected void composeQuestionnaireResponseQuestionnaireResponseItemAnswerComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent element, int index) { 10382 if (element == null) 10383 return; 10384 Complex t; 10385 if (Utilities.noString(parentType)) 10386 t = parent; 10387 else { 10388 t = parent.predicate("fhir:"+parentType+'.'+name); 10389 } 10390 composeBackboneElement(t, "answer", name, element, index); 10391 if (element.hasValue()) 10392 composeType(t, "QuestionnaireResponse", "value", element.getValue(), -1); 10393 for (int i = 0; i < element.getItem().size(); i++) 10394 composeQuestionnaireResponseQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i); 10395 } 10396 10397 protected void composeReferralRequest(Complex parent, String parentType, String name, ReferralRequest element, int index) { 10398 if (element == null) 10399 return; 10400 Complex t; 10401 if (Utilities.noString(parentType)) 10402 t = parent; 10403 else { 10404 t = parent.predicate("fhir:"+parentType+'.'+name); 10405 } 10406 composeDomainResource(t, "ReferralRequest", name, element, index); 10407 for (int i = 0; i < element.getIdentifier().size(); i++) 10408 composeIdentifier(t, "ReferralRequest", "identifier", element.getIdentifier().get(i), i); 10409 for (int i = 0; i < element.getDefinition().size(); i++) 10410 composeReference(t, "ReferralRequest", "definition", element.getDefinition().get(i), i); 10411 for (int i = 0; i < element.getBasedOn().size(); i++) 10412 composeReference(t, "ReferralRequest", "basedOn", element.getBasedOn().get(i), i); 10413 for (int i = 0; i < element.getReplaces().size(); i++) 10414 composeReference(t, "ReferralRequest", "replaces", element.getReplaces().get(i), i); 10415 if (element.hasGroupIdentifier()) 10416 composeIdentifier(t, "ReferralRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 10417 if (element.hasStatusElement()) 10418 composeEnum(t, "ReferralRequest", "status", element.getStatusElement(), -1); 10419 if (element.hasIntentElement()) 10420 composeEnum(t, "ReferralRequest", "intent", element.getIntentElement(), -1); 10421 if (element.hasType()) 10422 composeCodeableConcept(t, "ReferralRequest", "type", element.getType(), -1); 10423 if (element.hasPriorityElement()) 10424 composeEnum(t, "ReferralRequest", "priority", element.getPriorityElement(), -1); 10425 for (int i = 0; i < element.getServiceRequested().size(); i++) 10426 composeCodeableConcept(t, "ReferralRequest", "serviceRequested", element.getServiceRequested().get(i), i); 10427 if (element.hasSubject()) 10428 composeReference(t, "ReferralRequest", "subject", element.getSubject(), -1); 10429 if (element.hasContext()) 10430 composeReference(t, "ReferralRequest", "context", element.getContext(), -1); 10431 if (element.hasOccurrence()) 10432 composeType(t, "ReferralRequest", "occurrence", element.getOccurrence(), -1); 10433 if (element.hasAuthoredOnElement()) 10434 composeDateTime(t, "ReferralRequest", "authoredOn", element.getAuthoredOnElement(), -1); 10435 if (element.hasRequester()) 10436 composeReferralRequestReferralRequestRequesterComponent(t, "ReferralRequest", "requester", element.getRequester(), -1); 10437 if (element.hasSpecialty()) 10438 composeCodeableConcept(t, "ReferralRequest", "specialty", element.getSpecialty(), -1); 10439 for (int i = 0; i < element.getRecipient().size(); i++) 10440 composeReference(t, "ReferralRequest", "recipient", element.getRecipient().get(i), i); 10441 for (int i = 0; i < element.getReasonCode().size(); i++) 10442 composeCodeableConcept(t, "ReferralRequest", "reasonCode", element.getReasonCode().get(i), i); 10443 for (int i = 0; i < element.getReasonReference().size(); i++) 10444 composeReference(t, "ReferralRequest", "reasonReference", element.getReasonReference().get(i), i); 10445 if (element.hasDescriptionElement()) 10446 composeString(t, "ReferralRequest", "description", element.getDescriptionElement(), -1); 10447 for (int i = 0; i < element.getSupportingInfo().size(); i++) 10448 composeReference(t, "ReferralRequest", "supportingInfo", element.getSupportingInfo().get(i), i); 10449 for (int i = 0; i < element.getNote().size(); i++) 10450 composeAnnotation(t, "ReferralRequest", "note", element.getNote().get(i), i); 10451 for (int i = 0; i < element.getRelevantHistory().size(); i++) 10452 composeReference(t, "ReferralRequest", "relevantHistory", element.getRelevantHistory().get(i), i); 10453 } 10454 10455 protected void composeReferralRequestReferralRequestRequesterComponent(Complex parent, String parentType, String name, ReferralRequest.ReferralRequestRequesterComponent element, int index) { 10456 if (element == null) 10457 return; 10458 Complex t; 10459 if (Utilities.noString(parentType)) 10460 t = parent; 10461 else { 10462 t = parent.predicate("fhir:"+parentType+'.'+name); 10463 } 10464 composeBackboneElement(t, "requester", name, element, index); 10465 if (element.hasAgent()) 10466 composeReference(t, "ReferralRequest", "agent", element.getAgent(), -1); 10467 if (element.hasOnBehalfOf()) 10468 composeReference(t, "ReferralRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 10469 } 10470 10471 protected void composeRelatedPerson(Complex parent, String parentType, String name, RelatedPerson element, int index) { 10472 if (element == null) 10473 return; 10474 Complex t; 10475 if (Utilities.noString(parentType)) 10476 t = parent; 10477 else { 10478 t = parent.predicate("fhir:"+parentType+'.'+name); 10479 } 10480 composeDomainResource(t, "RelatedPerson", name, element, index); 10481 for (int i = 0; i < element.getIdentifier().size(); i++) 10482 composeIdentifier(t, "RelatedPerson", "identifier", element.getIdentifier().get(i), i); 10483 if (element.hasActiveElement()) 10484 composeBoolean(t, "RelatedPerson", "active", element.getActiveElement(), -1); 10485 if (element.hasPatient()) 10486 composeReference(t, "RelatedPerson", "patient", element.getPatient(), -1); 10487 if (element.hasRelationship()) 10488 composeCodeableConcept(t, "RelatedPerson", "relationship", element.getRelationship(), -1); 10489 for (int i = 0; i < element.getName().size(); i++) 10490 composeHumanName(t, "RelatedPerson", "name", element.getName().get(i), i); 10491 for (int i = 0; i < element.getTelecom().size(); i++) 10492 composeContactPoint(t, "RelatedPerson", "telecom", element.getTelecom().get(i), i); 10493 if (element.hasGenderElement()) 10494 composeEnum(t, "RelatedPerson", "gender", element.getGenderElement(), -1); 10495 if (element.hasBirthDateElement()) 10496 composeDate(t, "RelatedPerson", "birthDate", element.getBirthDateElement(), -1); 10497 for (int i = 0; i < element.getAddress().size(); i++) 10498 composeAddress(t, "RelatedPerson", "address", element.getAddress().get(i), i); 10499 for (int i = 0; i < element.getPhoto().size(); i++) 10500 composeAttachment(t, "RelatedPerson", "photo", element.getPhoto().get(i), i); 10501 if (element.hasPeriod()) 10502 composePeriod(t, "RelatedPerson", "period", element.getPeriod(), -1); 10503 } 10504 10505 protected void composeRequestGroup(Complex parent, String parentType, String name, RequestGroup element, int index) { 10506 if (element == null) 10507 return; 10508 Complex t; 10509 if (Utilities.noString(parentType)) 10510 t = parent; 10511 else { 10512 t = parent.predicate("fhir:"+parentType+'.'+name); 10513 } 10514 composeDomainResource(t, "RequestGroup", name, element, index); 10515 for (int i = 0; i < element.getIdentifier().size(); i++) 10516 composeIdentifier(t, "RequestGroup", "identifier", element.getIdentifier().get(i), i); 10517 for (int i = 0; i < element.getDefinition().size(); i++) 10518 composeReference(t, "RequestGroup", "definition", element.getDefinition().get(i), i); 10519 for (int i = 0; i < element.getBasedOn().size(); i++) 10520 composeReference(t, "RequestGroup", "basedOn", element.getBasedOn().get(i), i); 10521 for (int i = 0; i < element.getReplaces().size(); i++) 10522 composeReference(t, "RequestGroup", "replaces", element.getReplaces().get(i), i); 10523 if (element.hasGroupIdentifier()) 10524 composeIdentifier(t, "RequestGroup", "groupIdentifier", element.getGroupIdentifier(), -1); 10525 if (element.hasStatusElement()) 10526 composeEnum(t, "RequestGroup", "status", element.getStatusElement(), -1); 10527 if (element.hasIntentElement()) 10528 composeEnum(t, "RequestGroup", "intent", element.getIntentElement(), -1); 10529 if (element.hasPriorityElement()) 10530 composeEnum(t, "RequestGroup", "priority", element.getPriorityElement(), -1); 10531 if (element.hasSubject()) 10532 composeReference(t, "RequestGroup", "subject", element.getSubject(), -1); 10533 if (element.hasContext()) 10534 composeReference(t, "RequestGroup", "context", element.getContext(), -1); 10535 if (element.hasAuthoredOnElement()) 10536 composeDateTime(t, "RequestGroup", "authoredOn", element.getAuthoredOnElement(), -1); 10537 if (element.hasAuthor()) 10538 composeReference(t, "RequestGroup", "author", element.getAuthor(), -1); 10539 if (element.hasReason()) 10540 composeType(t, "RequestGroup", "reason", element.getReason(), -1); 10541 for (int i = 0; i < element.getNote().size(); i++) 10542 composeAnnotation(t, "RequestGroup", "note", element.getNote().get(i), i); 10543 for (int i = 0; i < element.getAction().size(); i++) 10544 composeRequestGroupRequestGroupActionComponent(t, "RequestGroup", "action", element.getAction().get(i), i); 10545 } 10546 10547 protected void composeRequestGroupRequestGroupActionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionComponent element, int index) { 10548 if (element == null) 10549 return; 10550 Complex t; 10551 if (Utilities.noString(parentType)) 10552 t = parent; 10553 else { 10554 t = parent.predicate("fhir:"+parentType+'.'+name); 10555 } 10556 composeBackboneElement(t, "action", name, element, index); 10557 if (element.hasLabelElement()) 10558 composeString(t, "RequestGroup", "label", element.getLabelElement(), -1); 10559 if (element.hasTitleElement()) 10560 composeString(t, "RequestGroup", "title", element.getTitleElement(), -1); 10561 if (element.hasDescriptionElement()) 10562 composeString(t, "RequestGroup", "description", element.getDescriptionElement(), -1); 10563 if (element.hasTextEquivalentElement()) 10564 composeString(t, "RequestGroup", "textEquivalent", element.getTextEquivalentElement(), -1); 10565 for (int i = 0; i < element.getCode().size(); i++) 10566 composeCodeableConcept(t, "RequestGroup", "code", element.getCode().get(i), i); 10567 for (int i = 0; i < element.getDocumentation().size(); i++) 10568 composeRelatedArtifact(t, "RequestGroup", "documentation", element.getDocumentation().get(i), i); 10569 for (int i = 0; i < element.getCondition().size(); i++) 10570 composeRequestGroupRequestGroupActionConditionComponent(t, "RequestGroup", "condition", element.getCondition().get(i), i); 10571 for (int i = 0; i < element.getRelatedAction().size(); i++) 10572 composeRequestGroupRequestGroupActionRelatedActionComponent(t, "RequestGroup", "relatedAction", element.getRelatedAction().get(i), i); 10573 if (element.hasTiming()) 10574 composeType(t, "RequestGroup", "timing", element.getTiming(), -1); 10575 for (int i = 0; i < element.getParticipant().size(); i++) 10576 composeReference(t, "RequestGroup", "participant", element.getParticipant().get(i), i); 10577 if (element.hasType()) 10578 composeCoding(t, "RequestGroup", "type", element.getType(), -1); 10579 if (element.hasGroupingBehaviorElement()) 10580 composeEnum(t, "RequestGroup", "groupingBehavior", element.getGroupingBehaviorElement(), -1); 10581 if (element.hasSelectionBehaviorElement()) 10582 composeEnum(t, "RequestGroup", "selectionBehavior", element.getSelectionBehaviorElement(), -1); 10583 if (element.hasRequiredBehaviorElement()) 10584 composeEnum(t, "RequestGroup", "requiredBehavior", element.getRequiredBehaviorElement(), -1); 10585 if (element.hasPrecheckBehaviorElement()) 10586 composeEnum(t, "RequestGroup", "precheckBehavior", element.getPrecheckBehaviorElement(), -1); 10587 if (element.hasCardinalityBehaviorElement()) 10588 composeEnum(t, "RequestGroup", "cardinalityBehavior", element.getCardinalityBehaviorElement(), -1); 10589 if (element.hasResource()) 10590 composeReference(t, "RequestGroup", "resource", element.getResource(), -1); 10591 for (int i = 0; i < element.getAction().size(); i++) 10592 composeRequestGroupRequestGroupActionComponent(t, "RequestGroup", "action", element.getAction().get(i), i); 10593 } 10594 10595 protected void composeRequestGroupRequestGroupActionConditionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionConditionComponent element, int index) { 10596 if (element == null) 10597 return; 10598 Complex t; 10599 if (Utilities.noString(parentType)) 10600 t = parent; 10601 else { 10602 t = parent.predicate("fhir:"+parentType+'.'+name); 10603 } 10604 composeBackboneElement(t, "condition", name, element, index); 10605 if (element.hasKindElement()) 10606 composeEnum(t, "RequestGroup", "kind", element.getKindElement(), -1); 10607 if (element.hasDescriptionElement()) 10608 composeString(t, "RequestGroup", "description", element.getDescriptionElement(), -1); 10609 if (element.hasLanguageElement()) 10610 composeString(t, "RequestGroup", "language", element.getLanguageElement(), -1); 10611 if (element.hasExpressionElement()) 10612 composeString(t, "RequestGroup", "expression", element.getExpressionElement(), -1); 10613 } 10614 10615 protected void composeRequestGroupRequestGroupActionRelatedActionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionRelatedActionComponent element, int index) { 10616 if (element == null) 10617 return; 10618 Complex t; 10619 if (Utilities.noString(parentType)) 10620 t = parent; 10621 else { 10622 t = parent.predicate("fhir:"+parentType+'.'+name); 10623 } 10624 composeBackboneElement(t, "relatedAction", name, element, index); 10625 if (element.hasActionIdElement()) 10626 composeId(t, "RequestGroup", "actionId", element.getActionIdElement(), -1); 10627 if (element.hasRelationshipElement()) 10628 composeEnum(t, "RequestGroup", "relationship", element.getRelationshipElement(), -1); 10629 if (element.hasOffset()) 10630 composeType(t, "RequestGroup", "offset", element.getOffset(), -1); 10631 } 10632 10633 protected void composeResearchStudy(Complex parent, String parentType, String name, ResearchStudy element, int index) { 10634 if (element == null) 10635 return; 10636 Complex t; 10637 if (Utilities.noString(parentType)) 10638 t = parent; 10639 else { 10640 t = parent.predicate("fhir:"+parentType+'.'+name); 10641 } 10642 composeDomainResource(t, "ResearchStudy", name, element, index); 10643 for (int i = 0; i < element.getIdentifier().size(); i++) 10644 composeIdentifier(t, "ResearchStudy", "identifier", element.getIdentifier().get(i), i); 10645 if (element.hasTitleElement()) 10646 composeString(t, "ResearchStudy", "title", element.getTitleElement(), -1); 10647 for (int i = 0; i < element.getProtocol().size(); i++) 10648 composeReference(t, "ResearchStudy", "protocol", element.getProtocol().get(i), i); 10649 for (int i = 0; i < element.getPartOf().size(); i++) 10650 composeReference(t, "ResearchStudy", "partOf", element.getPartOf().get(i), i); 10651 if (element.hasStatusElement()) 10652 composeEnum(t, "ResearchStudy", "status", element.getStatusElement(), -1); 10653 for (int i = 0; i < element.getCategory().size(); i++) 10654 composeCodeableConcept(t, "ResearchStudy", "category", element.getCategory().get(i), i); 10655 for (int i = 0; i < element.getFocus().size(); i++) 10656 composeCodeableConcept(t, "ResearchStudy", "focus", element.getFocus().get(i), i); 10657 for (int i = 0; i < element.getContact().size(); i++) 10658 composeContactDetail(t, "ResearchStudy", "contact", element.getContact().get(i), i); 10659 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 10660 composeRelatedArtifact(t, "ResearchStudy", "relatedArtifact", element.getRelatedArtifact().get(i), i); 10661 for (int i = 0; i < element.getKeyword().size(); i++) 10662 composeCodeableConcept(t, "ResearchStudy", "keyword", element.getKeyword().get(i), i); 10663 for (int i = 0; i < element.getJurisdiction().size(); i++) 10664 composeCodeableConcept(t, "ResearchStudy", "jurisdiction", element.getJurisdiction().get(i), i); 10665 if (element.hasDescriptionElement()) 10666 composeMarkdown(t, "ResearchStudy", "description", element.getDescriptionElement(), -1); 10667 for (int i = 0; i < element.getEnrollment().size(); i++) 10668 composeReference(t, "ResearchStudy", "enrollment", element.getEnrollment().get(i), i); 10669 if (element.hasPeriod()) 10670 composePeriod(t, "ResearchStudy", "period", element.getPeriod(), -1); 10671 if (element.hasSponsor()) 10672 composeReference(t, "ResearchStudy", "sponsor", element.getSponsor(), -1); 10673 if (element.hasPrincipalInvestigator()) 10674 composeReference(t, "ResearchStudy", "principalInvestigator", element.getPrincipalInvestigator(), -1); 10675 for (int i = 0; i < element.getSite().size(); i++) 10676 composeReference(t, "ResearchStudy", "site", element.getSite().get(i), i); 10677 if (element.hasReasonStopped()) 10678 composeCodeableConcept(t, "ResearchStudy", "reasonStopped", element.getReasonStopped(), -1); 10679 for (int i = 0; i < element.getNote().size(); i++) 10680 composeAnnotation(t, "ResearchStudy", "note", element.getNote().get(i), i); 10681 for (int i = 0; i < element.getArm().size(); i++) 10682 composeResearchStudyResearchStudyArmComponent(t, "ResearchStudy", "arm", element.getArm().get(i), i); 10683 } 10684 10685 protected void composeResearchStudyResearchStudyArmComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyArmComponent element, int index) { 10686 if (element == null) 10687 return; 10688 Complex t; 10689 if (Utilities.noString(parentType)) 10690 t = parent; 10691 else { 10692 t = parent.predicate("fhir:"+parentType+'.'+name); 10693 } 10694 composeBackboneElement(t, "arm", name, element, index); 10695 if (element.hasNameElement()) 10696 composeString(t, "ResearchStudy", "name", element.getNameElement(), -1); 10697 if (element.hasCode()) 10698 composeCodeableConcept(t, "ResearchStudy", "code", element.getCode(), -1); 10699 if (element.hasDescriptionElement()) 10700 composeString(t, "ResearchStudy", "description", element.getDescriptionElement(), -1); 10701 } 10702 10703 protected void composeResearchSubject(Complex parent, String parentType, String name, ResearchSubject element, int index) { 10704 if (element == null) 10705 return; 10706 Complex t; 10707 if (Utilities.noString(parentType)) 10708 t = parent; 10709 else { 10710 t = parent.predicate("fhir:"+parentType+'.'+name); 10711 } 10712 composeDomainResource(t, "ResearchSubject", name, element, index); 10713 if (element.hasIdentifier()) 10714 composeIdentifier(t, "ResearchSubject", "identifier", element.getIdentifier(), -1); 10715 if (element.hasStatusElement()) 10716 composeEnum(t, "ResearchSubject", "status", element.getStatusElement(), -1); 10717 if (element.hasPeriod()) 10718 composePeriod(t, "ResearchSubject", "period", element.getPeriod(), -1); 10719 if (element.hasStudy()) 10720 composeReference(t, "ResearchSubject", "study", element.getStudy(), -1); 10721 if (element.hasIndividual()) 10722 composeReference(t, "ResearchSubject", "individual", element.getIndividual(), -1); 10723 if (element.hasAssignedArmElement()) 10724 composeString(t, "ResearchSubject", "assignedArm", element.getAssignedArmElement(), -1); 10725 if (element.hasActualArmElement()) 10726 composeString(t, "ResearchSubject", "actualArm", element.getActualArmElement(), -1); 10727 if (element.hasConsent()) 10728 composeReference(t, "ResearchSubject", "consent", element.getConsent(), -1); 10729 } 10730 10731 protected void composeRiskAssessment(Complex parent, String parentType, String name, RiskAssessment element, int index) { 10732 if (element == null) 10733 return; 10734 Complex t; 10735 if (Utilities.noString(parentType)) 10736 t = parent; 10737 else { 10738 t = parent.predicate("fhir:"+parentType+'.'+name); 10739 } 10740 composeDomainResource(t, "RiskAssessment", name, element, index); 10741 if (element.hasIdentifier()) 10742 composeIdentifier(t, "RiskAssessment", "identifier", element.getIdentifier(), -1); 10743 if (element.hasBasedOn()) 10744 composeReference(t, "RiskAssessment", "basedOn", element.getBasedOn(), -1); 10745 if (element.hasParent()) 10746 composeReference(t, "RiskAssessment", "parent", element.getParent(), -1); 10747 if (element.hasStatusElement()) 10748 composeEnum(t, "RiskAssessment", "status", element.getStatusElement(), -1); 10749 if (element.hasMethod()) 10750 composeCodeableConcept(t, "RiskAssessment", "method", element.getMethod(), -1); 10751 if (element.hasCode()) 10752 composeCodeableConcept(t, "RiskAssessment", "code", element.getCode(), -1); 10753 if (element.hasSubject()) 10754 composeReference(t, "RiskAssessment", "subject", element.getSubject(), -1); 10755 if (element.hasContext()) 10756 composeReference(t, "RiskAssessment", "context", element.getContext(), -1); 10757 if (element.hasOccurrence()) 10758 composeType(t, "RiskAssessment", "occurrence", element.getOccurrence(), -1); 10759 if (element.hasCondition()) 10760 composeReference(t, "RiskAssessment", "condition", element.getCondition(), -1); 10761 if (element.hasPerformer()) 10762 composeReference(t, "RiskAssessment", "performer", element.getPerformer(), -1); 10763 if (element.hasReason()) 10764 composeType(t, "RiskAssessment", "reason", element.getReason(), -1); 10765 for (int i = 0; i < element.getBasis().size(); i++) 10766 composeReference(t, "RiskAssessment", "basis", element.getBasis().get(i), i); 10767 for (int i = 0; i < element.getPrediction().size(); i++) 10768 composeRiskAssessmentRiskAssessmentPredictionComponent(t, "RiskAssessment", "prediction", element.getPrediction().get(i), i); 10769 if (element.hasMitigationElement()) 10770 composeString(t, "RiskAssessment", "mitigation", element.getMitigationElement(), -1); 10771 if (element.hasCommentElement()) 10772 composeString(t, "RiskAssessment", "comment", element.getCommentElement(), -1); 10773 } 10774 10775 protected void composeRiskAssessmentRiskAssessmentPredictionComponent(Complex parent, String parentType, String name, RiskAssessment.RiskAssessmentPredictionComponent element, int index) { 10776 if (element == null) 10777 return; 10778 Complex t; 10779 if (Utilities.noString(parentType)) 10780 t = parent; 10781 else { 10782 t = parent.predicate("fhir:"+parentType+'.'+name); 10783 } 10784 composeBackboneElement(t, "prediction", name, element, index); 10785 if (element.hasOutcome()) 10786 composeCodeableConcept(t, "RiskAssessment", "outcome", element.getOutcome(), -1); 10787 if (element.hasProbability()) 10788 composeType(t, "RiskAssessment", "probability", element.getProbability(), -1); 10789 if (element.hasQualitativeRisk()) 10790 composeCodeableConcept(t, "RiskAssessment", "qualitativeRisk", element.getQualitativeRisk(), -1); 10791 if (element.hasRelativeRiskElement()) 10792 composeDecimal(t, "RiskAssessment", "relativeRisk", element.getRelativeRiskElement(), -1); 10793 if (element.hasWhen()) 10794 composeType(t, "RiskAssessment", "when", element.getWhen(), -1); 10795 if (element.hasRationaleElement()) 10796 composeString(t, "RiskAssessment", "rationale", element.getRationaleElement(), -1); 10797 } 10798 10799 protected void composeSchedule(Complex parent, String parentType, String name, Schedule element, int index) { 10800 if (element == null) 10801 return; 10802 Complex t; 10803 if (Utilities.noString(parentType)) 10804 t = parent; 10805 else { 10806 t = parent.predicate("fhir:"+parentType+'.'+name); 10807 } 10808 composeDomainResource(t, "Schedule", name, element, index); 10809 for (int i = 0; i < element.getIdentifier().size(); i++) 10810 composeIdentifier(t, "Schedule", "identifier", element.getIdentifier().get(i), i); 10811 if (element.hasActiveElement()) 10812 composeBoolean(t, "Schedule", "active", element.getActiveElement(), -1); 10813 if (element.hasServiceCategory()) 10814 composeCodeableConcept(t, "Schedule", "serviceCategory", element.getServiceCategory(), -1); 10815 for (int i = 0; i < element.getServiceType().size(); i++) 10816 composeCodeableConcept(t, "Schedule", "serviceType", element.getServiceType().get(i), i); 10817 for (int i = 0; i < element.getSpecialty().size(); i++) 10818 composeCodeableConcept(t, "Schedule", "specialty", element.getSpecialty().get(i), i); 10819 for (int i = 0; i < element.getActor().size(); i++) 10820 composeReference(t, "Schedule", "actor", element.getActor().get(i), i); 10821 if (element.hasPlanningHorizon()) 10822 composePeriod(t, "Schedule", "planningHorizon", element.getPlanningHorizon(), -1); 10823 if (element.hasCommentElement()) 10824 composeString(t, "Schedule", "comment", element.getCommentElement(), -1); 10825 } 10826 10827 protected void composeSearchParameter(Complex parent, String parentType, String name, SearchParameter element, int index) { 10828 if (element == null) 10829 return; 10830 Complex t; 10831 if (Utilities.noString(parentType)) 10832 t = parent; 10833 else { 10834 t = parent.predicate("fhir:"+parentType+'.'+name); 10835 } 10836 composeDomainResource(t, "SearchParameter", name, element, index); 10837 if (element.hasUrlElement()) 10838 composeUri(t, "SearchParameter", "url", element.getUrlElement(), -1); 10839 if (element.hasVersionElement()) 10840 composeString(t, "SearchParameter", "version", element.getVersionElement(), -1); 10841 if (element.hasNameElement()) 10842 composeString(t, "SearchParameter", "name", element.getNameElement(), -1); 10843 if (element.hasStatusElement()) 10844 composeEnum(t, "SearchParameter", "status", element.getStatusElement(), -1); 10845 if (element.hasExperimentalElement()) 10846 composeBoolean(t, "SearchParameter", "experimental", element.getExperimentalElement(), -1); 10847 if (element.hasDateElement()) 10848 composeDateTime(t, "SearchParameter", "date", element.getDateElement(), -1); 10849 if (element.hasPublisherElement()) 10850 composeString(t, "SearchParameter", "publisher", element.getPublisherElement(), -1); 10851 for (int i = 0; i < element.getContact().size(); i++) 10852 composeContactDetail(t, "SearchParameter", "contact", element.getContact().get(i), i); 10853 for (int i = 0; i < element.getUseContext().size(); i++) 10854 composeUsageContext(t, "SearchParameter", "useContext", element.getUseContext().get(i), i); 10855 for (int i = 0; i < element.getJurisdiction().size(); i++) 10856 composeCodeableConcept(t, "SearchParameter", "jurisdiction", element.getJurisdiction().get(i), i); 10857 if (element.hasPurposeElement()) 10858 composeMarkdown(t, "SearchParameter", "purpose", element.getPurposeElement(), -1); 10859 if (element.hasCodeElement()) 10860 composeCode(t, "SearchParameter", "code", element.getCodeElement(), -1); 10861 for (int i = 0; i < element.getBase().size(); i++) 10862 composeCode(t, "SearchParameter", "base", element.getBase().get(i), i); 10863 if (element.hasTypeElement()) 10864 composeEnum(t, "SearchParameter", "type", element.getTypeElement(), -1); 10865 if (element.hasDerivedFromElement()) 10866 composeUri(t, "SearchParameter", "derivedFrom", element.getDerivedFromElement(), -1); 10867 if (element.hasDescriptionElement()) 10868 composeMarkdown(t, "SearchParameter", "description", element.getDescriptionElement(), -1); 10869 if (element.hasExpressionElement()) 10870 composeString(t, "SearchParameter", "expression", element.getExpressionElement(), -1); 10871 if (element.hasXpathElement()) 10872 composeString(t, "SearchParameter", "xpath", element.getXpathElement(), -1); 10873 if (element.hasXpathUsageElement()) 10874 composeEnum(t, "SearchParameter", "xpathUsage", element.getXpathUsageElement(), -1); 10875 for (int i = 0; i < element.getTarget().size(); i++) 10876 composeCode(t, "SearchParameter", "target", element.getTarget().get(i), i); 10877 for (int i = 0; i < element.getComparator().size(); i++) 10878 composeEnum(t, "SearchParameter", "comparator", element.getComparator().get(i), i); 10879 for (int i = 0; i < element.getModifier().size(); i++) 10880 composeEnum(t, "SearchParameter", "modifier", element.getModifier().get(i), i); 10881 for (int i = 0; i < element.getChain().size(); i++) 10882 composeString(t, "SearchParameter", "chain", element.getChain().get(i), i); 10883 for (int i = 0; i < element.getComponent().size(); i++) 10884 composeSearchParameterSearchParameterComponentComponent(t, "SearchParameter", "component", element.getComponent().get(i), i); 10885 } 10886 10887 protected void composeSearchParameterSearchParameterComponentComponent(Complex parent, String parentType, String name, SearchParameter.SearchParameterComponentComponent element, int index) { 10888 if (element == null) 10889 return; 10890 Complex t; 10891 if (Utilities.noString(parentType)) 10892 t = parent; 10893 else { 10894 t = parent.predicate("fhir:"+parentType+'.'+name); 10895 } 10896 composeBackboneElement(t, "component", name, element, index); 10897 if (element.hasDefinition()) 10898 composeReference(t, "SearchParameter", "definition", element.getDefinition(), -1); 10899 if (element.hasExpressionElement()) 10900 composeString(t, "SearchParameter", "expression", element.getExpressionElement(), -1); 10901 } 10902 10903 protected void composeSequence(Complex parent, String parentType, String name, Sequence element, int index) { 10904 if (element == null) 10905 return; 10906 Complex t; 10907 if (Utilities.noString(parentType)) 10908 t = parent; 10909 else { 10910 t = parent.predicate("fhir:"+parentType+'.'+name); 10911 } 10912 composeDomainResource(t, "Sequence", name, element, index); 10913 for (int i = 0; i < element.getIdentifier().size(); i++) 10914 composeIdentifier(t, "Sequence", "identifier", element.getIdentifier().get(i), i); 10915 if (element.hasTypeElement()) 10916 composeEnum(t, "Sequence", "type", element.getTypeElement(), -1); 10917 if (element.hasCoordinateSystemElement()) 10918 composeInteger(t, "Sequence", "coordinateSystem", element.getCoordinateSystemElement(), -1); 10919 if (element.hasPatient()) 10920 composeReference(t, "Sequence", "patient", element.getPatient(), -1); 10921 if (element.hasSpecimen()) 10922 composeReference(t, "Sequence", "specimen", element.getSpecimen(), -1); 10923 if (element.hasDevice()) 10924 composeReference(t, "Sequence", "device", element.getDevice(), -1); 10925 if (element.hasPerformer()) 10926 composeReference(t, "Sequence", "performer", element.getPerformer(), -1); 10927 if (element.hasQuantity()) 10928 composeQuantity(t, "Sequence", "quantity", element.getQuantity(), -1); 10929 if (element.hasReferenceSeq()) 10930 composeSequenceSequenceReferenceSeqComponent(t, "Sequence", "referenceSeq", element.getReferenceSeq(), -1); 10931 for (int i = 0; i < element.getVariant().size(); i++) 10932 composeSequenceSequenceVariantComponent(t, "Sequence", "variant", element.getVariant().get(i), i); 10933 if (element.hasObservedSeqElement()) 10934 composeString(t, "Sequence", "observedSeq", element.getObservedSeqElement(), -1); 10935 for (int i = 0; i < element.getQuality().size(); i++) 10936 composeSequenceSequenceQualityComponent(t, "Sequence", "quality", element.getQuality().get(i), i); 10937 if (element.hasReadCoverageElement()) 10938 composeInteger(t, "Sequence", "readCoverage", element.getReadCoverageElement(), -1); 10939 for (int i = 0; i < element.getRepository().size(); i++) 10940 composeSequenceSequenceRepositoryComponent(t, "Sequence", "repository", element.getRepository().get(i), i); 10941 for (int i = 0; i < element.getPointer().size(); i++) 10942 composeReference(t, "Sequence", "pointer", element.getPointer().get(i), i); 10943 } 10944 10945 protected void composeSequenceSequenceReferenceSeqComponent(Complex parent, String parentType, String name, Sequence.SequenceReferenceSeqComponent element, int index) { 10946 if (element == null) 10947 return; 10948 Complex t; 10949 if (Utilities.noString(parentType)) 10950 t = parent; 10951 else { 10952 t = parent.predicate("fhir:"+parentType+'.'+name); 10953 } 10954 composeBackboneElement(t, "referenceSeq", name, element, index); 10955 if (element.hasChromosome()) 10956 composeCodeableConcept(t, "Sequence", "chromosome", element.getChromosome(), -1); 10957 if (element.hasGenomeBuildElement()) 10958 composeString(t, "Sequence", "genomeBuild", element.getGenomeBuildElement(), -1); 10959 if (element.hasReferenceSeqId()) 10960 composeCodeableConcept(t, "Sequence", "referenceSeqId", element.getReferenceSeqId(), -1); 10961 if (element.hasReferenceSeqPointer()) 10962 composeReference(t, "Sequence", "referenceSeqPointer", element.getReferenceSeqPointer(), -1); 10963 if (element.hasReferenceSeqStringElement()) 10964 composeString(t, "Sequence", "referenceSeqString", element.getReferenceSeqStringElement(), -1); 10965 if (element.hasStrandElement()) 10966 composeInteger(t, "Sequence", "strand", element.getStrandElement(), -1); 10967 if (element.hasWindowStartElement()) 10968 composeInteger(t, "Sequence", "windowStart", element.getWindowStartElement(), -1); 10969 if (element.hasWindowEndElement()) 10970 composeInteger(t, "Sequence", "windowEnd", element.getWindowEndElement(), -1); 10971 } 10972 10973 protected void composeSequenceSequenceVariantComponent(Complex parent, String parentType, String name, Sequence.SequenceVariantComponent element, int index) { 10974 if (element == null) 10975 return; 10976 Complex t; 10977 if (Utilities.noString(parentType)) 10978 t = parent; 10979 else { 10980 t = parent.predicate("fhir:"+parentType+'.'+name); 10981 } 10982 composeBackboneElement(t, "variant", name, element, index); 10983 if (element.hasStartElement()) 10984 composeInteger(t, "Sequence", "start", element.getStartElement(), -1); 10985 if (element.hasEndElement()) 10986 composeInteger(t, "Sequence", "end", element.getEndElement(), -1); 10987 if (element.hasObservedAlleleElement()) 10988 composeString(t, "Sequence", "observedAllele", element.getObservedAlleleElement(), -1); 10989 if (element.hasReferenceAlleleElement()) 10990 composeString(t, "Sequence", "referenceAllele", element.getReferenceAlleleElement(), -1); 10991 if (element.hasCigarElement()) 10992 composeString(t, "Sequence", "cigar", element.getCigarElement(), -1); 10993 if (element.hasVariantPointer()) 10994 composeReference(t, "Sequence", "variantPointer", element.getVariantPointer(), -1); 10995 } 10996 10997 protected void composeSequenceSequenceQualityComponent(Complex parent, String parentType, String name, Sequence.SequenceQualityComponent element, int index) { 10998 if (element == null) 10999 return; 11000 Complex t; 11001 if (Utilities.noString(parentType)) 11002 t = parent; 11003 else { 11004 t = parent.predicate("fhir:"+parentType+'.'+name); 11005 } 11006 composeBackboneElement(t, "quality", name, element, index); 11007 if (element.hasTypeElement()) 11008 composeEnum(t, "Sequence", "type", element.getTypeElement(), -1); 11009 if (element.hasStandardSequence()) 11010 composeCodeableConcept(t, "Sequence", "standardSequence", element.getStandardSequence(), -1); 11011 if (element.hasStartElement()) 11012 composeInteger(t, "Sequence", "start", element.getStartElement(), -1); 11013 if (element.hasEndElement()) 11014 composeInteger(t, "Sequence", "end", element.getEndElement(), -1); 11015 if (element.hasScore()) 11016 composeQuantity(t, "Sequence", "score", element.getScore(), -1); 11017 if (element.hasMethod()) 11018 composeCodeableConcept(t, "Sequence", "method", element.getMethod(), -1); 11019 if (element.hasTruthTPElement()) 11020 composeDecimal(t, "Sequence", "truthTP", element.getTruthTPElement(), -1); 11021 if (element.hasQueryTPElement()) 11022 composeDecimal(t, "Sequence", "queryTP", element.getQueryTPElement(), -1); 11023 if (element.hasTruthFNElement()) 11024 composeDecimal(t, "Sequence", "truthFN", element.getTruthFNElement(), -1); 11025 if (element.hasQueryFPElement()) 11026 composeDecimal(t, "Sequence", "queryFP", element.getQueryFPElement(), -1); 11027 if (element.hasGtFPElement()) 11028 composeDecimal(t, "Sequence", "gtFP", element.getGtFPElement(), -1); 11029 if (element.hasPrecisionElement()) 11030 composeDecimal(t, "Sequence", "precision", element.getPrecisionElement(), -1); 11031 if (element.hasRecallElement()) 11032 composeDecimal(t, "Sequence", "recall", element.getRecallElement(), -1); 11033 if (element.hasFScoreElement()) 11034 composeDecimal(t, "Sequence", "fScore", element.getFScoreElement(), -1); 11035 } 11036 11037 protected void composeSequenceSequenceRepositoryComponent(Complex parent, String parentType, String name, Sequence.SequenceRepositoryComponent element, int index) { 11038 if (element == null) 11039 return; 11040 Complex t; 11041 if (Utilities.noString(parentType)) 11042 t = parent; 11043 else { 11044 t = parent.predicate("fhir:"+parentType+'.'+name); 11045 } 11046 composeBackboneElement(t, "repository", name, element, index); 11047 if (element.hasTypeElement()) 11048 composeEnum(t, "Sequence", "type", element.getTypeElement(), -1); 11049 if (element.hasUrlElement()) 11050 composeUri(t, "Sequence", "url", element.getUrlElement(), -1); 11051 if (element.hasNameElement()) 11052 composeString(t, "Sequence", "name", element.getNameElement(), -1); 11053 if (element.hasDatasetIdElement()) 11054 composeString(t, "Sequence", "datasetId", element.getDatasetIdElement(), -1); 11055 if (element.hasVariantsetIdElement()) 11056 composeString(t, "Sequence", "variantsetId", element.getVariantsetIdElement(), -1); 11057 if (element.hasReadsetIdElement()) 11058 composeString(t, "Sequence", "readsetId", element.getReadsetIdElement(), -1); 11059 } 11060 11061 protected void composeServiceDefinition(Complex parent, String parentType, String name, ServiceDefinition element, int index) { 11062 if (element == null) 11063 return; 11064 Complex t; 11065 if (Utilities.noString(parentType)) 11066 t = parent; 11067 else { 11068 t = parent.predicate("fhir:"+parentType+'.'+name); 11069 } 11070 composeDomainResource(t, "ServiceDefinition", name, element, index); 11071 if (element.hasUrlElement()) 11072 composeUri(t, "ServiceDefinition", "url", element.getUrlElement(), -1); 11073 for (int i = 0; i < element.getIdentifier().size(); i++) 11074 composeIdentifier(t, "ServiceDefinition", "identifier", element.getIdentifier().get(i), i); 11075 if (element.hasVersionElement()) 11076 composeString(t, "ServiceDefinition", "version", element.getVersionElement(), -1); 11077 if (element.hasNameElement()) 11078 composeString(t, "ServiceDefinition", "name", element.getNameElement(), -1); 11079 if (element.hasTitleElement()) 11080 composeString(t, "ServiceDefinition", "title", element.getTitleElement(), -1); 11081 if (element.hasStatusElement()) 11082 composeEnum(t, "ServiceDefinition", "status", element.getStatusElement(), -1); 11083 if (element.hasExperimentalElement()) 11084 composeBoolean(t, "ServiceDefinition", "experimental", element.getExperimentalElement(), -1); 11085 if (element.hasDateElement()) 11086 composeDateTime(t, "ServiceDefinition", "date", element.getDateElement(), -1); 11087 if (element.hasPublisherElement()) 11088 composeString(t, "ServiceDefinition", "publisher", element.getPublisherElement(), -1); 11089 if (element.hasDescriptionElement()) 11090 composeMarkdown(t, "ServiceDefinition", "description", element.getDescriptionElement(), -1); 11091 if (element.hasPurposeElement()) 11092 composeMarkdown(t, "ServiceDefinition", "purpose", element.getPurposeElement(), -1); 11093 if (element.hasUsageElement()) 11094 composeString(t, "ServiceDefinition", "usage", element.getUsageElement(), -1); 11095 if (element.hasApprovalDateElement()) 11096 composeDate(t, "ServiceDefinition", "approvalDate", element.getApprovalDateElement(), -1); 11097 if (element.hasLastReviewDateElement()) 11098 composeDate(t, "ServiceDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 11099 if (element.hasEffectivePeriod()) 11100 composePeriod(t, "ServiceDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 11101 for (int i = 0; i < element.getUseContext().size(); i++) 11102 composeUsageContext(t, "ServiceDefinition", "useContext", element.getUseContext().get(i), i); 11103 for (int i = 0; i < element.getJurisdiction().size(); i++) 11104 composeCodeableConcept(t, "ServiceDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 11105 for (int i = 0; i < element.getTopic().size(); i++) 11106 composeCodeableConcept(t, "ServiceDefinition", "topic", element.getTopic().get(i), i); 11107 for (int i = 0; i < element.getContributor().size(); i++) 11108 composeContributor(t, "ServiceDefinition", "contributor", element.getContributor().get(i), i); 11109 for (int i = 0; i < element.getContact().size(); i++) 11110 composeContactDetail(t, "ServiceDefinition", "contact", element.getContact().get(i), i); 11111 if (element.hasCopyrightElement()) 11112 composeMarkdown(t, "ServiceDefinition", "copyright", element.getCopyrightElement(), -1); 11113 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 11114 composeRelatedArtifact(t, "ServiceDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 11115 for (int i = 0; i < element.getTrigger().size(); i++) 11116 composeTriggerDefinition(t, "ServiceDefinition", "trigger", element.getTrigger().get(i), i); 11117 for (int i = 0; i < element.getDataRequirement().size(); i++) 11118 composeDataRequirement(t, "ServiceDefinition", "dataRequirement", element.getDataRequirement().get(i), i); 11119 if (element.hasOperationDefinition()) 11120 composeReference(t, "ServiceDefinition", "operationDefinition", element.getOperationDefinition(), -1); 11121 } 11122 11123 protected void composeSlot(Complex parent, String parentType, String name, Slot element, int index) { 11124 if (element == null) 11125 return; 11126 Complex t; 11127 if (Utilities.noString(parentType)) 11128 t = parent; 11129 else { 11130 t = parent.predicate("fhir:"+parentType+'.'+name); 11131 } 11132 composeDomainResource(t, "Slot", name, element, index); 11133 for (int i = 0; i < element.getIdentifier().size(); i++) 11134 composeIdentifier(t, "Slot", "identifier", element.getIdentifier().get(i), i); 11135 if (element.hasServiceCategory()) 11136 composeCodeableConcept(t, "Slot", "serviceCategory", element.getServiceCategory(), -1); 11137 for (int i = 0; i < element.getServiceType().size(); i++) 11138 composeCodeableConcept(t, "Slot", "serviceType", element.getServiceType().get(i), i); 11139 for (int i = 0; i < element.getSpecialty().size(); i++) 11140 composeCodeableConcept(t, "Slot", "specialty", element.getSpecialty().get(i), i); 11141 if (element.hasAppointmentType()) 11142 composeCodeableConcept(t, "Slot", "appointmentType", element.getAppointmentType(), -1); 11143 if (element.hasSchedule()) 11144 composeReference(t, "Slot", "schedule", element.getSchedule(), -1); 11145 if (element.hasStatusElement()) 11146 composeEnum(t, "Slot", "status", element.getStatusElement(), -1); 11147 if (element.hasStartElement()) 11148 composeInstant(t, "Slot", "start", element.getStartElement(), -1); 11149 if (element.hasEndElement()) 11150 composeInstant(t, "Slot", "end", element.getEndElement(), -1); 11151 if (element.hasOverbookedElement()) 11152 composeBoolean(t, "Slot", "overbooked", element.getOverbookedElement(), -1); 11153 if (element.hasCommentElement()) 11154 composeString(t, "Slot", "comment", element.getCommentElement(), -1); 11155 } 11156 11157 protected void composeSpecimen(Complex parent, String parentType, String name, Specimen element, int index) { 11158 if (element == null) 11159 return; 11160 Complex t; 11161 if (Utilities.noString(parentType)) 11162 t = parent; 11163 else { 11164 t = parent.predicate("fhir:"+parentType+'.'+name); 11165 } 11166 composeDomainResource(t, "Specimen", name, element, index); 11167 for (int i = 0; i < element.getIdentifier().size(); i++) 11168 composeIdentifier(t, "Specimen", "identifier", element.getIdentifier().get(i), i); 11169 if (element.hasAccessionIdentifier()) 11170 composeIdentifier(t, "Specimen", "accessionIdentifier", element.getAccessionIdentifier(), -1); 11171 if (element.hasStatusElement()) 11172 composeEnum(t, "Specimen", "status", element.getStatusElement(), -1); 11173 if (element.hasType()) 11174 composeCodeableConcept(t, "Specimen", "type", element.getType(), -1); 11175 if (element.hasSubject()) 11176 composeReference(t, "Specimen", "subject", element.getSubject(), -1); 11177 if (element.hasReceivedTimeElement()) 11178 composeDateTime(t, "Specimen", "receivedTime", element.getReceivedTimeElement(), -1); 11179 for (int i = 0; i < element.getParent().size(); i++) 11180 composeReference(t, "Specimen", "parent", element.getParent().get(i), i); 11181 for (int i = 0; i < element.getRequest().size(); i++) 11182 composeReference(t, "Specimen", "request", element.getRequest().get(i), i); 11183 if (element.hasCollection()) 11184 composeSpecimenSpecimenCollectionComponent(t, "Specimen", "collection", element.getCollection(), -1); 11185 for (int i = 0; i < element.getProcessing().size(); i++) 11186 composeSpecimenSpecimenProcessingComponent(t, "Specimen", "processing", element.getProcessing().get(i), i); 11187 for (int i = 0; i < element.getContainer().size(); i++) 11188 composeSpecimenSpecimenContainerComponent(t, "Specimen", "container", element.getContainer().get(i), i); 11189 for (int i = 0; i < element.getNote().size(); i++) 11190 composeAnnotation(t, "Specimen", "note", element.getNote().get(i), i); 11191 } 11192 11193 protected void composeSpecimenSpecimenCollectionComponent(Complex parent, String parentType, String name, Specimen.SpecimenCollectionComponent element, int index) { 11194 if (element == null) 11195 return; 11196 Complex t; 11197 if (Utilities.noString(parentType)) 11198 t = parent; 11199 else { 11200 t = parent.predicate("fhir:"+parentType+'.'+name); 11201 } 11202 composeBackboneElement(t, "collection", name, element, index); 11203 if (element.hasCollector()) 11204 composeReference(t, "Specimen", "collector", element.getCollector(), -1); 11205 if (element.hasCollected()) 11206 composeType(t, "Specimen", "collected", element.getCollected(), -1); 11207 if (element.hasQuantity()) 11208 composeQuantity(t, "Specimen", "quantity", element.getQuantity(), -1); 11209 if (element.hasMethod()) 11210 composeCodeableConcept(t, "Specimen", "method", element.getMethod(), -1); 11211 if (element.hasBodySite()) 11212 composeCodeableConcept(t, "Specimen", "bodySite", element.getBodySite(), -1); 11213 } 11214 11215 protected void composeSpecimenSpecimenProcessingComponent(Complex parent, String parentType, String name, Specimen.SpecimenProcessingComponent element, int index) { 11216 if (element == null) 11217 return; 11218 Complex t; 11219 if (Utilities.noString(parentType)) 11220 t = parent; 11221 else { 11222 t = parent.predicate("fhir:"+parentType+'.'+name); 11223 } 11224 composeBackboneElement(t, "processing", name, element, index); 11225 if (element.hasDescriptionElement()) 11226 composeString(t, "Specimen", "description", element.getDescriptionElement(), -1); 11227 if (element.hasProcedure()) 11228 composeCodeableConcept(t, "Specimen", "procedure", element.getProcedure(), -1); 11229 for (int i = 0; i < element.getAdditive().size(); i++) 11230 composeReference(t, "Specimen", "additive", element.getAdditive().get(i), i); 11231 if (element.hasTime()) 11232 composeType(t, "Specimen", "time", element.getTime(), -1); 11233 } 11234 11235 protected void composeSpecimenSpecimenContainerComponent(Complex parent, String parentType, String name, Specimen.SpecimenContainerComponent element, int index) { 11236 if (element == null) 11237 return; 11238 Complex t; 11239 if (Utilities.noString(parentType)) 11240 t = parent; 11241 else { 11242 t = parent.predicate("fhir:"+parentType+'.'+name); 11243 } 11244 composeBackboneElement(t, "container", name, element, index); 11245 for (int i = 0; i < element.getIdentifier().size(); i++) 11246 composeIdentifier(t, "Specimen", "identifier", element.getIdentifier().get(i), i); 11247 if (element.hasDescriptionElement()) 11248 composeString(t, "Specimen", "description", element.getDescriptionElement(), -1); 11249 if (element.hasType()) 11250 composeCodeableConcept(t, "Specimen", "type", element.getType(), -1); 11251 if (element.hasCapacity()) 11252 composeQuantity(t, "Specimen", "capacity", element.getCapacity(), -1); 11253 if (element.hasSpecimenQuantity()) 11254 composeQuantity(t, "Specimen", "specimenQuantity", element.getSpecimenQuantity(), -1); 11255 if (element.hasAdditive()) 11256 composeType(t, "Specimen", "additive", element.getAdditive(), -1); 11257 } 11258 11259 protected void composeStructureDefinition(Complex parent, String parentType, String name, StructureDefinition element, int index) { 11260 if (element == null) 11261 return; 11262 Complex t; 11263 if (Utilities.noString(parentType)) 11264 t = parent; 11265 else { 11266 t = parent.predicate("fhir:"+parentType+'.'+name); 11267 } 11268 composeDomainResource(t, "StructureDefinition", name, element, index); 11269 if (element.hasUrlElement()) 11270 composeUri(t, "StructureDefinition", "url", element.getUrlElement(), -1); 11271 for (int i = 0; i < element.getIdentifier().size(); i++) 11272 composeIdentifier(t, "StructureDefinition", "identifier", element.getIdentifier().get(i), i); 11273 if (element.hasVersionElement()) 11274 composeString(t, "StructureDefinition", "version", element.getVersionElement(), -1); 11275 if (element.hasNameElement()) 11276 composeString(t, "StructureDefinition", "name", element.getNameElement(), -1); 11277 if (element.hasTitleElement()) 11278 composeString(t, "StructureDefinition", "title", element.getTitleElement(), -1); 11279 if (element.hasStatusElement()) 11280 composeEnum(t, "StructureDefinition", "status", element.getStatusElement(), -1); 11281 if (element.hasExperimentalElement()) 11282 composeBoolean(t, "StructureDefinition", "experimental", element.getExperimentalElement(), -1); 11283 if (element.hasDateElement()) 11284 composeDateTime(t, "StructureDefinition", "date", element.getDateElement(), -1); 11285 if (element.hasPublisherElement()) 11286 composeString(t, "StructureDefinition", "publisher", element.getPublisherElement(), -1); 11287 for (int i = 0; i < element.getContact().size(); i++) 11288 composeContactDetail(t, "StructureDefinition", "contact", element.getContact().get(i), i); 11289 if (element.hasDescriptionElement()) 11290 composeMarkdown(t, "StructureDefinition", "description", element.getDescriptionElement(), -1); 11291 for (int i = 0; i < element.getUseContext().size(); i++) 11292 composeUsageContext(t, "StructureDefinition", "useContext", element.getUseContext().get(i), i); 11293 for (int i = 0; i < element.getJurisdiction().size(); i++) 11294 composeCodeableConcept(t, "StructureDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 11295 if (element.hasPurposeElement()) 11296 composeMarkdown(t, "StructureDefinition", "purpose", element.getPurposeElement(), -1); 11297 if (element.hasCopyrightElement()) 11298 composeMarkdown(t, "StructureDefinition", "copyright", element.getCopyrightElement(), -1); 11299 for (int i = 0; i < element.getKeyword().size(); i++) 11300 composeCoding(t, "StructureDefinition", "keyword", element.getKeyword().get(i), i); 11301 if (element.hasFhirVersionElement()) 11302 composeId(t, "StructureDefinition", "fhirVersion", element.getFhirVersionElement(), -1); 11303 for (int i = 0; i < element.getMapping().size(); i++) 11304 composeStructureDefinitionStructureDefinitionMappingComponent(t, "StructureDefinition", "mapping", element.getMapping().get(i), i); 11305 if (element.hasKindElement()) 11306 composeEnum(t, "StructureDefinition", "kind", element.getKindElement(), -1); 11307 if (element.hasAbstractElement()) 11308 composeBoolean(t, "StructureDefinition", "abstract", element.getAbstractElement(), -1); 11309 if (element.hasContextTypeElement()) 11310 composeEnum(t, "StructureDefinition", "contextType", element.getContextTypeElement(), -1); 11311 for (int i = 0; i < element.getContext().size(); i++) 11312 composeString(t, "StructureDefinition", "context", element.getContext().get(i), i); 11313 for (int i = 0; i < element.getContextInvariant().size(); i++) 11314 composeString(t, "StructureDefinition", "contextInvariant", element.getContextInvariant().get(i), i); 11315 if (element.hasTypeElement()) 11316 composeCode(t, "StructureDefinition", "type", element.getTypeElement(), -1); 11317 if (element.hasBaseDefinitionElement()) 11318 composeUri(t, "StructureDefinition", "baseDefinition", element.getBaseDefinitionElement(), -1); 11319 if (element.hasDerivationElement()) 11320 composeEnum(t, "StructureDefinition", "derivation", element.getDerivationElement(), -1); 11321 if (element.hasSnapshot()) 11322 composeStructureDefinitionStructureDefinitionSnapshotComponent(t, "StructureDefinition", "snapshot", element.getSnapshot(), -1); 11323 if (element.hasDifferential()) 11324 composeStructureDefinitionStructureDefinitionDifferentialComponent(t, "StructureDefinition", "differential", element.getDifferential(), -1); 11325 } 11326 11327 protected void composeStructureDefinitionStructureDefinitionMappingComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionMappingComponent element, int index) { 11328 if (element == null) 11329 return; 11330 Complex t; 11331 if (Utilities.noString(parentType)) 11332 t = parent; 11333 else { 11334 t = parent.predicate("fhir:"+parentType+'.'+name); 11335 } 11336 composeBackboneElement(t, "mapping", name, element, index); 11337 if (element.hasIdentityElement()) 11338 composeId(t, "StructureDefinition", "identity", element.getIdentityElement(), -1); 11339 if (element.hasUriElement()) 11340 composeUri(t, "StructureDefinition", "uri", element.getUriElement(), -1); 11341 if (element.hasNameElement()) 11342 composeString(t, "StructureDefinition", "name", element.getNameElement(), -1); 11343 if (element.hasCommentElement()) 11344 composeString(t, "StructureDefinition", "comment", element.getCommentElement(), -1); 11345 } 11346 11347 protected void composeStructureDefinitionStructureDefinitionSnapshotComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionSnapshotComponent element, int index) { 11348 if (element == null) 11349 return; 11350 Complex t; 11351 if (Utilities.noString(parentType)) 11352 t = parent; 11353 else { 11354 t = parent.predicate("fhir:"+parentType+'.'+name); 11355 } 11356 composeBackboneElement(t, "snapshot", name, element, index); 11357 for (int i = 0; i < element.getElement().size(); i++) 11358 composeElementDefinition(t, "StructureDefinition", "element", element.getElement().get(i), i); 11359 } 11360 11361 protected void composeStructureDefinitionStructureDefinitionDifferentialComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionDifferentialComponent element, int index) { 11362 if (element == null) 11363 return; 11364 Complex t; 11365 if (Utilities.noString(parentType)) 11366 t = parent; 11367 else { 11368 t = parent.predicate("fhir:"+parentType+'.'+name); 11369 } 11370 composeBackboneElement(t, "differential", name, element, index); 11371 for (int i = 0; i < element.getElement().size(); i++) 11372 composeElementDefinition(t, "StructureDefinition", "element", element.getElement().get(i), i); 11373 } 11374 11375 protected void composeStructureMap(Complex parent, String parentType, String name, StructureMap element, int index) { 11376 if (element == null) 11377 return; 11378 Complex t; 11379 if (Utilities.noString(parentType)) 11380 t = parent; 11381 else { 11382 t = parent.predicate("fhir:"+parentType+'.'+name); 11383 } 11384 composeDomainResource(t, "StructureMap", name, element, index); 11385 if (element.hasUrlElement()) 11386 composeUri(t, "StructureMap", "url", element.getUrlElement(), -1); 11387 for (int i = 0; i < element.getIdentifier().size(); i++) 11388 composeIdentifier(t, "StructureMap", "identifier", element.getIdentifier().get(i), i); 11389 if (element.hasVersionElement()) 11390 composeString(t, "StructureMap", "version", element.getVersionElement(), -1); 11391 if (element.hasNameElement()) 11392 composeString(t, "StructureMap", "name", element.getNameElement(), -1); 11393 if (element.hasTitleElement()) 11394 composeString(t, "StructureMap", "title", element.getTitleElement(), -1); 11395 if (element.hasStatusElement()) 11396 composeEnum(t, "StructureMap", "status", element.getStatusElement(), -1); 11397 if (element.hasExperimentalElement()) 11398 composeBoolean(t, "StructureMap", "experimental", element.getExperimentalElement(), -1); 11399 if (element.hasDateElement()) 11400 composeDateTime(t, "StructureMap", "date", element.getDateElement(), -1); 11401 if (element.hasPublisherElement()) 11402 composeString(t, "StructureMap", "publisher", element.getPublisherElement(), -1); 11403 for (int i = 0; i < element.getContact().size(); i++) 11404 composeContactDetail(t, "StructureMap", "contact", element.getContact().get(i), i); 11405 if (element.hasDescriptionElement()) 11406 composeMarkdown(t, "StructureMap", "description", element.getDescriptionElement(), -1); 11407 for (int i = 0; i < element.getUseContext().size(); i++) 11408 composeUsageContext(t, "StructureMap", "useContext", element.getUseContext().get(i), i); 11409 for (int i = 0; i < element.getJurisdiction().size(); i++) 11410 composeCodeableConcept(t, "StructureMap", "jurisdiction", element.getJurisdiction().get(i), i); 11411 if (element.hasPurposeElement()) 11412 composeMarkdown(t, "StructureMap", "purpose", element.getPurposeElement(), -1); 11413 if (element.hasCopyrightElement()) 11414 composeMarkdown(t, "StructureMap", "copyright", element.getCopyrightElement(), -1); 11415 for (int i = 0; i < element.getStructure().size(); i++) 11416 composeStructureMapStructureMapStructureComponent(t, "StructureMap", "structure", element.getStructure().get(i), i); 11417 for (int i = 0; i < element.getImport().size(); i++) 11418 composeUri(t, "StructureMap", "import", element.getImport().get(i), i); 11419 for (int i = 0; i < element.getGroup().size(); i++) 11420 composeStructureMapStructureMapGroupComponent(t, "StructureMap", "group", element.getGroup().get(i), i); 11421 } 11422 11423 protected void composeStructureMapStructureMapStructureComponent(Complex parent, String parentType, String name, StructureMap.StructureMapStructureComponent element, int index) { 11424 if (element == null) 11425 return; 11426 Complex t; 11427 if (Utilities.noString(parentType)) 11428 t = parent; 11429 else { 11430 t = parent.predicate("fhir:"+parentType+'.'+name); 11431 } 11432 composeBackboneElement(t, "structure", name, element, index); 11433 if (element.hasUrlElement()) 11434 composeUri(t, "StructureMap", "url", element.getUrlElement(), -1); 11435 if (element.hasModeElement()) 11436 composeEnum(t, "StructureMap", "mode", element.getModeElement(), -1); 11437 if (element.hasAliasElement()) 11438 composeString(t, "StructureMap", "alias", element.getAliasElement(), -1); 11439 if (element.hasDocumentationElement()) 11440 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 11441 } 11442 11443 protected void composeStructureMapStructureMapGroupComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupComponent element, int index) { 11444 if (element == null) 11445 return; 11446 Complex t; 11447 if (Utilities.noString(parentType)) 11448 t = parent; 11449 else { 11450 t = parent.predicate("fhir:"+parentType+'.'+name); 11451 } 11452 composeBackboneElement(t, "group", name, element, index); 11453 if (element.hasNameElement()) 11454 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 11455 if (element.hasExtendsElement()) 11456 composeId(t, "StructureMap", "extends", element.getExtendsElement(), -1); 11457 if (element.hasTypeModeElement()) 11458 composeEnum(t, "StructureMap", "typeMode", element.getTypeModeElement(), -1); 11459 if (element.hasDocumentationElement()) 11460 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 11461 for (int i = 0; i < element.getInput().size(); i++) 11462 composeStructureMapStructureMapGroupInputComponent(t, "StructureMap", "input", element.getInput().get(i), i); 11463 for (int i = 0; i < element.getRule().size(); i++) 11464 composeStructureMapStructureMapGroupRuleComponent(t, "StructureMap", "rule", element.getRule().get(i), i); 11465 } 11466 11467 protected void composeStructureMapStructureMapGroupInputComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupInputComponent element, int index) { 11468 if (element == null) 11469 return; 11470 Complex t; 11471 if (Utilities.noString(parentType)) 11472 t = parent; 11473 else { 11474 t = parent.predicate("fhir:"+parentType+'.'+name); 11475 } 11476 composeBackboneElement(t, "input", name, element, index); 11477 if (element.hasNameElement()) 11478 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 11479 if (element.hasTypeElement()) 11480 composeString(t, "StructureMap", "type", element.getTypeElement(), -1); 11481 if (element.hasModeElement()) 11482 composeEnum(t, "StructureMap", "mode", element.getModeElement(), -1); 11483 if (element.hasDocumentationElement()) 11484 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 11485 } 11486 11487 protected void composeStructureMapStructureMapGroupRuleComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleComponent element, int index) { 11488 if (element == null) 11489 return; 11490 Complex t; 11491 if (Utilities.noString(parentType)) 11492 t = parent; 11493 else { 11494 t = parent.predicate("fhir:"+parentType+'.'+name); 11495 } 11496 composeBackboneElement(t, "rule", name, element, index); 11497 if (element.hasNameElement()) 11498 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 11499 for (int i = 0; i < element.getSource().size(); i++) 11500 composeStructureMapStructureMapGroupRuleSourceComponent(t, "StructureMap", "source", element.getSource().get(i), i); 11501 for (int i = 0; i < element.getTarget().size(); i++) 11502 composeStructureMapStructureMapGroupRuleTargetComponent(t, "StructureMap", "target", element.getTarget().get(i), i); 11503 for (int i = 0; i < element.getRule().size(); i++) 11504 composeStructureMapStructureMapGroupRuleComponent(t, "StructureMap", "rule", element.getRule().get(i), i); 11505 for (int i = 0; i < element.getDependent().size(); i++) 11506 composeStructureMapStructureMapGroupRuleDependentComponent(t, "StructureMap", "dependent", element.getDependent().get(i), i); 11507 if (element.hasDocumentationElement()) 11508 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 11509 } 11510 11511 protected void composeStructureMapStructureMapGroupRuleSourceComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleSourceComponent element, int index) { 11512 if (element == null) 11513 return; 11514 Complex t; 11515 if (Utilities.noString(parentType)) 11516 t = parent; 11517 else { 11518 t = parent.predicate("fhir:"+parentType+'.'+name); 11519 } 11520 composeBackboneElement(t, "source", name, element, index); 11521 if (element.hasContextElement()) 11522 composeId(t, "StructureMap", "context", element.getContextElement(), -1); 11523 if (element.hasMinElement()) 11524 composeInteger(t, "StructureMap", "min", element.getMinElement(), -1); 11525 if (element.hasMaxElement()) 11526 composeString(t, "StructureMap", "max", element.getMaxElement(), -1); 11527 if (element.hasTypeElement()) 11528 composeString(t, "StructureMap", "type", element.getTypeElement(), -1); 11529 if (element.hasDefaultValue()) 11530 composeType(t, "StructureMap", "defaultValue", element.getDefaultValue(), -1); 11531 if (element.hasElementElement()) 11532 composeString(t, "StructureMap", "element", element.getElementElement(), -1); 11533 if (element.hasListModeElement()) 11534 composeEnum(t, "StructureMap", "listMode", element.getListModeElement(), -1); 11535 if (element.hasVariableElement()) 11536 composeId(t, "StructureMap", "variable", element.getVariableElement(), -1); 11537 if (element.hasConditionElement()) 11538 composeString(t, "StructureMap", "condition", element.getConditionElement(), -1); 11539 if (element.hasCheckElement()) 11540 composeString(t, "StructureMap", "check", element.getCheckElement(), -1); 11541 } 11542 11543 protected void composeStructureMapStructureMapGroupRuleTargetComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetComponent element, int index) { 11544 if (element == null) 11545 return; 11546 Complex t; 11547 if (Utilities.noString(parentType)) 11548 t = parent; 11549 else { 11550 t = parent.predicate("fhir:"+parentType+'.'+name); 11551 } 11552 composeBackboneElement(t, "target", name, element, index); 11553 if (element.hasContextElement()) 11554 composeId(t, "StructureMap", "context", element.getContextElement(), -1); 11555 if (element.hasContextTypeElement()) 11556 composeEnum(t, "StructureMap", "contextType", element.getContextTypeElement(), -1); 11557 if (element.hasElementElement()) 11558 composeString(t, "StructureMap", "element", element.getElementElement(), -1); 11559 if (element.hasVariableElement()) 11560 composeId(t, "StructureMap", "variable", element.getVariableElement(), -1); 11561 for (int i = 0; i < element.getListMode().size(); i++) 11562 composeEnum(t, "StructureMap", "listMode", element.getListMode().get(i), i); 11563 if (element.hasListRuleIdElement()) 11564 composeId(t, "StructureMap", "listRuleId", element.getListRuleIdElement(), -1); 11565 if (element.hasTransformElement()) 11566 composeEnum(t, "StructureMap", "transform", element.getTransformElement(), -1); 11567 for (int i = 0; i < element.getParameter().size(); i++) 11568 composeStructureMapStructureMapGroupRuleTargetParameterComponent(t, "StructureMap", "parameter", element.getParameter().get(i), i); 11569 } 11570 11571 protected void composeStructureMapStructureMapGroupRuleTargetParameterComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetParameterComponent element, int index) { 11572 if (element == null) 11573 return; 11574 Complex t; 11575 if (Utilities.noString(parentType)) 11576 t = parent; 11577 else { 11578 t = parent.predicate("fhir:"+parentType+'.'+name); 11579 } 11580 composeBackboneElement(t, "parameter", name, element, index); 11581 if (element.hasValue()) 11582 composeType(t, "StructureMap", "value", element.getValue(), -1); 11583 } 11584 11585 protected void composeStructureMapStructureMapGroupRuleDependentComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleDependentComponent element, int index) { 11586 if (element == null) 11587 return; 11588 Complex t; 11589 if (Utilities.noString(parentType)) 11590 t = parent; 11591 else { 11592 t = parent.predicate("fhir:"+parentType+'.'+name); 11593 } 11594 composeBackboneElement(t, "dependent", name, element, index); 11595 if (element.hasNameElement()) 11596 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 11597 for (int i = 0; i < element.getVariable().size(); i++) 11598 composeString(t, "StructureMap", "variable", element.getVariable().get(i), i); 11599 } 11600 11601 protected void composeSubscription(Complex parent, String parentType, String name, Subscription element, int index) { 11602 if (element == null) 11603 return; 11604 Complex t; 11605 if (Utilities.noString(parentType)) 11606 t = parent; 11607 else { 11608 t = parent.predicate("fhir:"+parentType+'.'+name); 11609 } 11610 composeDomainResource(t, "Subscription", name, element, index); 11611 if (element.hasStatusElement()) 11612 composeEnum(t, "Subscription", "status", element.getStatusElement(), -1); 11613 for (int i = 0; i < element.getContact().size(); i++) 11614 composeContactPoint(t, "Subscription", "contact", element.getContact().get(i), i); 11615 if (element.hasEndElement()) 11616 composeInstant(t, "Subscription", "end", element.getEndElement(), -1); 11617 if (element.hasReasonElement()) 11618 composeString(t, "Subscription", "reason", element.getReasonElement(), -1); 11619 if (element.hasCriteriaElement()) 11620 composeString(t, "Subscription", "criteria", element.getCriteriaElement(), -1); 11621 if (element.hasErrorElement()) 11622 composeString(t, "Subscription", "error", element.getErrorElement(), -1); 11623 if (element.hasChannel()) 11624 composeSubscriptionSubscriptionChannelComponent(t, "Subscription", "channel", element.getChannel(), -1); 11625 for (int i = 0; i < element.getTag().size(); i++) 11626 composeCoding(t, "Subscription", "tag", element.getTag().get(i), i); 11627 } 11628 11629 protected void composeSubscriptionSubscriptionChannelComponent(Complex parent, String parentType, String name, Subscription.SubscriptionChannelComponent element, int index) { 11630 if (element == null) 11631 return; 11632 Complex t; 11633 if (Utilities.noString(parentType)) 11634 t = parent; 11635 else { 11636 t = parent.predicate("fhir:"+parentType+'.'+name); 11637 } 11638 composeBackboneElement(t, "channel", name, element, index); 11639 if (element.hasTypeElement()) 11640 composeEnum(t, "Subscription", "type", element.getTypeElement(), -1); 11641 if (element.hasEndpointElement()) 11642 composeUri(t, "Subscription", "endpoint", element.getEndpointElement(), -1); 11643 if (element.hasPayloadElement()) 11644 composeString(t, "Subscription", "payload", element.getPayloadElement(), -1); 11645 for (int i = 0; i < element.getHeader().size(); i++) 11646 composeString(t, "Subscription", "header", element.getHeader().get(i), i); 11647 } 11648 11649 protected void composeSubstance(Complex parent, String parentType, String name, Substance element, int index) { 11650 if (element == null) 11651 return; 11652 Complex t; 11653 if (Utilities.noString(parentType)) 11654 t = parent; 11655 else { 11656 t = parent.predicate("fhir:"+parentType+'.'+name); 11657 } 11658 composeDomainResource(t, "Substance", name, element, index); 11659 for (int i = 0; i < element.getIdentifier().size(); i++) 11660 composeIdentifier(t, "Substance", "identifier", element.getIdentifier().get(i), i); 11661 if (element.hasStatusElement()) 11662 composeEnum(t, "Substance", "status", element.getStatusElement(), -1); 11663 for (int i = 0; i < element.getCategory().size(); i++) 11664 composeCodeableConcept(t, "Substance", "category", element.getCategory().get(i), i); 11665 if (element.hasCode()) 11666 composeCodeableConcept(t, "Substance", "code", element.getCode(), -1); 11667 if (element.hasDescriptionElement()) 11668 composeString(t, "Substance", "description", element.getDescriptionElement(), -1); 11669 for (int i = 0; i < element.getInstance().size(); i++) 11670 composeSubstanceSubstanceInstanceComponent(t, "Substance", "instance", element.getInstance().get(i), i); 11671 for (int i = 0; i < element.getIngredient().size(); i++) 11672 composeSubstanceSubstanceIngredientComponent(t, "Substance", "ingredient", element.getIngredient().get(i), i); 11673 } 11674 11675 protected void composeSubstanceSubstanceInstanceComponent(Complex parent, String parentType, String name, Substance.SubstanceInstanceComponent element, int index) { 11676 if (element == null) 11677 return; 11678 Complex t; 11679 if (Utilities.noString(parentType)) 11680 t = parent; 11681 else { 11682 t = parent.predicate("fhir:"+parentType+'.'+name); 11683 } 11684 composeBackboneElement(t, "instance", name, element, index); 11685 if (element.hasIdentifier()) 11686 composeIdentifier(t, "Substance", "identifier", element.getIdentifier(), -1); 11687 if (element.hasExpiryElement()) 11688 composeDateTime(t, "Substance", "expiry", element.getExpiryElement(), -1); 11689 if (element.hasQuantity()) 11690 composeQuantity(t, "Substance", "quantity", element.getQuantity(), -1); 11691 } 11692 11693 protected void composeSubstanceSubstanceIngredientComponent(Complex parent, String parentType, String name, Substance.SubstanceIngredientComponent element, int index) { 11694 if (element == null) 11695 return; 11696 Complex t; 11697 if (Utilities.noString(parentType)) 11698 t = parent; 11699 else { 11700 t = parent.predicate("fhir:"+parentType+'.'+name); 11701 } 11702 composeBackboneElement(t, "ingredient", name, element, index); 11703 if (element.hasQuantity()) 11704 composeRatio(t, "Substance", "quantity", element.getQuantity(), -1); 11705 if (element.hasSubstance()) 11706 composeType(t, "Substance", "substance", element.getSubstance(), -1); 11707 } 11708 11709 protected void composeSupplyDelivery(Complex parent, String parentType, String name, SupplyDelivery element, int index) { 11710 if (element == null) 11711 return; 11712 Complex t; 11713 if (Utilities.noString(parentType)) 11714 t = parent; 11715 else { 11716 t = parent.predicate("fhir:"+parentType+'.'+name); 11717 } 11718 composeDomainResource(t, "SupplyDelivery", name, element, index); 11719 if (element.hasIdentifier()) 11720 composeIdentifier(t, "SupplyDelivery", "identifier", element.getIdentifier(), -1); 11721 for (int i = 0; i < element.getBasedOn().size(); i++) 11722 composeReference(t, "SupplyDelivery", "basedOn", element.getBasedOn().get(i), i); 11723 for (int i = 0; i < element.getPartOf().size(); i++) 11724 composeReference(t, "SupplyDelivery", "partOf", element.getPartOf().get(i), i); 11725 if (element.hasStatusElement()) 11726 composeEnum(t, "SupplyDelivery", "status", element.getStatusElement(), -1); 11727 if (element.hasPatient()) 11728 composeReference(t, "SupplyDelivery", "patient", element.getPatient(), -1); 11729 if (element.hasType()) 11730 composeCodeableConcept(t, "SupplyDelivery", "type", element.getType(), -1); 11731 if (element.hasSuppliedItem()) 11732 composeSupplyDeliverySupplyDeliverySuppliedItemComponent(t, "SupplyDelivery", "suppliedItem", element.getSuppliedItem(), -1); 11733 if (element.hasOccurrence()) 11734 composeType(t, "SupplyDelivery", "occurrence", element.getOccurrence(), -1); 11735 if (element.hasSupplier()) 11736 composeReference(t, "SupplyDelivery", "supplier", element.getSupplier(), -1); 11737 if (element.hasDestination()) 11738 composeReference(t, "SupplyDelivery", "destination", element.getDestination(), -1); 11739 for (int i = 0; i < element.getReceiver().size(); i++) 11740 composeReference(t, "SupplyDelivery", "receiver", element.getReceiver().get(i), i); 11741 } 11742 11743 protected void composeSupplyDeliverySupplyDeliverySuppliedItemComponent(Complex parent, String parentType, String name, SupplyDelivery.SupplyDeliverySuppliedItemComponent element, int index) { 11744 if (element == null) 11745 return; 11746 Complex t; 11747 if (Utilities.noString(parentType)) 11748 t = parent; 11749 else { 11750 t = parent.predicate("fhir:"+parentType+'.'+name); 11751 } 11752 composeBackboneElement(t, "suppliedItem", name, element, index); 11753 if (element.hasQuantity()) 11754 composeQuantity(t, "SupplyDelivery", "quantity", element.getQuantity(), -1); 11755 if (element.hasItem()) 11756 composeType(t, "SupplyDelivery", "item", element.getItem(), -1); 11757 } 11758 11759 protected void composeSupplyRequest(Complex parent, String parentType, String name, SupplyRequest element, int index) { 11760 if (element == null) 11761 return; 11762 Complex t; 11763 if (Utilities.noString(parentType)) 11764 t = parent; 11765 else { 11766 t = parent.predicate("fhir:"+parentType+'.'+name); 11767 } 11768 composeDomainResource(t, "SupplyRequest", name, element, index); 11769 if (element.hasIdentifier()) 11770 composeIdentifier(t, "SupplyRequest", "identifier", element.getIdentifier(), -1); 11771 if (element.hasStatusElement()) 11772 composeEnum(t, "SupplyRequest", "status", element.getStatusElement(), -1); 11773 if (element.hasCategory()) 11774 composeCodeableConcept(t, "SupplyRequest", "category", element.getCategory(), -1); 11775 if (element.hasPriorityElement()) 11776 composeEnum(t, "SupplyRequest", "priority", element.getPriorityElement(), -1); 11777 if (element.hasOrderedItem()) 11778 composeSupplyRequestSupplyRequestOrderedItemComponent(t, "SupplyRequest", "orderedItem", element.getOrderedItem(), -1); 11779 if (element.hasOccurrence()) 11780 composeType(t, "SupplyRequest", "occurrence", element.getOccurrence(), -1); 11781 if (element.hasAuthoredOnElement()) 11782 composeDateTime(t, "SupplyRequest", "authoredOn", element.getAuthoredOnElement(), -1); 11783 if (element.hasRequester()) 11784 composeSupplyRequestSupplyRequestRequesterComponent(t, "SupplyRequest", "requester", element.getRequester(), -1); 11785 for (int i = 0; i < element.getSupplier().size(); i++) 11786 composeReference(t, "SupplyRequest", "supplier", element.getSupplier().get(i), i); 11787 if (element.hasReason()) 11788 composeType(t, "SupplyRequest", "reason", element.getReason(), -1); 11789 if (element.hasDeliverFrom()) 11790 composeReference(t, "SupplyRequest", "deliverFrom", element.getDeliverFrom(), -1); 11791 if (element.hasDeliverTo()) 11792 composeReference(t, "SupplyRequest", "deliverTo", element.getDeliverTo(), -1); 11793 } 11794 11795 protected void composeSupplyRequestSupplyRequestOrderedItemComponent(Complex parent, String parentType, String name, SupplyRequest.SupplyRequestOrderedItemComponent element, int index) { 11796 if (element == null) 11797 return; 11798 Complex t; 11799 if (Utilities.noString(parentType)) 11800 t = parent; 11801 else { 11802 t = parent.predicate("fhir:"+parentType+'.'+name); 11803 } 11804 composeBackboneElement(t, "orderedItem", name, element, index); 11805 if (element.hasQuantity()) 11806 composeQuantity(t, "SupplyRequest", "quantity", element.getQuantity(), -1); 11807 if (element.hasItem()) 11808 composeType(t, "SupplyRequest", "item", element.getItem(), -1); 11809 } 11810 11811 protected void composeSupplyRequestSupplyRequestRequesterComponent(Complex parent, String parentType, String name, SupplyRequest.SupplyRequestRequesterComponent element, int index) { 11812 if (element == null) 11813 return; 11814 Complex t; 11815 if (Utilities.noString(parentType)) 11816 t = parent; 11817 else { 11818 t = parent.predicate("fhir:"+parentType+'.'+name); 11819 } 11820 composeBackboneElement(t, "requester", name, element, index); 11821 if (element.hasAgent()) 11822 composeReference(t, "SupplyRequest", "agent", element.getAgent(), -1); 11823 if (element.hasOnBehalfOf()) 11824 composeReference(t, "SupplyRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 11825 } 11826 11827 protected void composeTask(Complex parent, String parentType, String name, Task element, int index) { 11828 if (element == null) 11829 return; 11830 Complex t; 11831 if (Utilities.noString(parentType)) 11832 t = parent; 11833 else { 11834 t = parent.predicate("fhir:"+parentType+'.'+name); 11835 } 11836 composeDomainResource(t, "Task", name, element, index); 11837 for (int i = 0; i < element.getIdentifier().size(); i++) 11838 composeIdentifier(t, "Task", "identifier", element.getIdentifier().get(i), i); 11839 if (element.hasDefinition()) 11840 composeType(t, "Task", "definition", element.getDefinition(), -1); 11841 for (int i = 0; i < element.getBasedOn().size(); i++) 11842 composeReference(t, "Task", "basedOn", element.getBasedOn().get(i), i); 11843 if (element.hasGroupIdentifier()) 11844 composeIdentifier(t, "Task", "groupIdentifier", element.getGroupIdentifier(), -1); 11845 for (int i = 0; i < element.getPartOf().size(); i++) 11846 composeReference(t, "Task", "partOf", element.getPartOf().get(i), i); 11847 if (element.hasStatusElement()) 11848 composeEnum(t, "Task", "status", element.getStatusElement(), -1); 11849 if (element.hasStatusReason()) 11850 composeCodeableConcept(t, "Task", "statusReason", element.getStatusReason(), -1); 11851 if (element.hasBusinessStatus()) 11852 composeCodeableConcept(t, "Task", "businessStatus", element.getBusinessStatus(), -1); 11853 if (element.hasIntentElement()) 11854 composeEnum(t, "Task", "intent", element.getIntentElement(), -1); 11855 if (element.hasPriorityElement()) 11856 composeEnum(t, "Task", "priority", element.getPriorityElement(), -1); 11857 if (element.hasCode()) 11858 composeCodeableConcept(t, "Task", "code", element.getCode(), -1); 11859 if (element.hasDescriptionElement()) 11860 composeString(t, "Task", "description", element.getDescriptionElement(), -1); 11861 if (element.hasFocus()) 11862 composeReference(t, "Task", "focus", element.getFocus(), -1); 11863 if (element.hasFor()) 11864 composeReference(t, "Task", "for", element.getFor(), -1); 11865 if (element.hasContext()) 11866 composeReference(t, "Task", "context", element.getContext(), -1); 11867 if (element.hasExecutionPeriod()) 11868 composePeriod(t, "Task", "executionPeriod", element.getExecutionPeriod(), -1); 11869 if (element.hasAuthoredOnElement()) 11870 composeDateTime(t, "Task", "authoredOn", element.getAuthoredOnElement(), -1); 11871 if (element.hasLastModifiedElement()) 11872 composeDateTime(t, "Task", "lastModified", element.getLastModifiedElement(), -1); 11873 if (element.hasRequester()) 11874 composeTaskTaskRequesterComponent(t, "Task", "requester", element.getRequester(), -1); 11875 for (int i = 0; i < element.getPerformerType().size(); i++) 11876 composeCodeableConcept(t, "Task", "performerType", element.getPerformerType().get(i), i); 11877 if (element.hasOwner()) 11878 composeReference(t, "Task", "owner", element.getOwner(), -1); 11879 if (element.hasReason()) 11880 composeCodeableConcept(t, "Task", "reason", element.getReason(), -1); 11881 for (int i = 0; i < element.getNote().size(); i++) 11882 composeAnnotation(t, "Task", "note", element.getNote().get(i), i); 11883 for (int i = 0; i < element.getRelevantHistory().size(); i++) 11884 composeReference(t, "Task", "relevantHistory", element.getRelevantHistory().get(i), i); 11885 if (element.hasRestriction()) 11886 composeTaskTaskRestrictionComponent(t, "Task", "restriction", element.getRestriction(), -1); 11887 for (int i = 0; i < element.getInput().size(); i++) 11888 composeTaskParameterComponent(t, "Task", "input", element.getInput().get(i), i); 11889 for (int i = 0; i < element.getOutput().size(); i++) 11890 composeTaskTaskOutputComponent(t, "Task", "output", element.getOutput().get(i), i); 11891 } 11892 11893 protected void composeTaskTaskRequesterComponent(Complex parent, String parentType, String name, Task.TaskRequesterComponent element, int index) { 11894 if (element == null) 11895 return; 11896 Complex t; 11897 if (Utilities.noString(parentType)) 11898 t = parent; 11899 else { 11900 t = parent.predicate("fhir:"+parentType+'.'+name); 11901 } 11902 composeBackboneElement(t, "requester", name, element, index); 11903 if (element.hasAgent()) 11904 composeReference(t, "Task", "agent", element.getAgent(), -1); 11905 if (element.hasOnBehalfOf()) 11906 composeReference(t, "Task", "onBehalfOf", element.getOnBehalfOf(), -1); 11907 } 11908 11909 protected void composeTaskTaskRestrictionComponent(Complex parent, String parentType, String name, Task.TaskRestrictionComponent element, int index) { 11910 if (element == null) 11911 return; 11912 Complex t; 11913 if (Utilities.noString(parentType)) 11914 t = parent; 11915 else { 11916 t = parent.predicate("fhir:"+parentType+'.'+name); 11917 } 11918 composeBackboneElement(t, "restriction", name, element, index); 11919 if (element.hasRepetitionsElement()) 11920 composePositiveInt(t, "Task", "repetitions", element.getRepetitionsElement(), -1); 11921 if (element.hasPeriod()) 11922 composePeriod(t, "Task", "period", element.getPeriod(), -1); 11923 for (int i = 0; i < element.getRecipient().size(); i++) 11924 composeReference(t, "Task", "recipient", element.getRecipient().get(i), i); 11925 } 11926 11927 protected void composeTaskParameterComponent(Complex parent, String parentType, String name, Task.ParameterComponent element, int index) { 11928 if (element == null) 11929 return; 11930 Complex t; 11931 if (Utilities.noString(parentType)) 11932 t = parent; 11933 else { 11934 t = parent.predicate("fhir:"+parentType+'.'+name); 11935 } 11936 composeBackboneElement(t, "input", name, element, index); 11937 if (element.hasType()) 11938 composeCodeableConcept(t, "Task", "type", element.getType(), -1); 11939 if (element.hasValue()) 11940 composeType(t, "Task", "value", element.getValue(), -1); 11941 } 11942 11943 protected void composeTaskTaskOutputComponent(Complex parent, String parentType, String name, Task.TaskOutputComponent element, int index) { 11944 if (element == null) 11945 return; 11946 Complex t; 11947 if (Utilities.noString(parentType)) 11948 t = parent; 11949 else { 11950 t = parent.predicate("fhir:"+parentType+'.'+name); 11951 } 11952 composeBackboneElement(t, "output", name, element, index); 11953 if (element.hasType()) 11954 composeCodeableConcept(t, "Task", "type", element.getType(), -1); 11955 if (element.hasValue()) 11956 composeType(t, "Task", "value", element.getValue(), -1); 11957 } 11958 11959 protected void composeTestReport(Complex parent, String parentType, String name, TestReport element, int index) { 11960 if (element == null) 11961 return; 11962 Complex t; 11963 if (Utilities.noString(parentType)) 11964 t = parent; 11965 else { 11966 t = parent.predicate("fhir:"+parentType+'.'+name); 11967 } 11968 composeDomainResource(t, "TestReport", name, element, index); 11969 if (element.hasIdentifier()) 11970 composeIdentifier(t, "TestReport", "identifier", element.getIdentifier(), -1); 11971 if (element.hasNameElement()) 11972 composeString(t, "TestReport", "name", element.getNameElement(), -1); 11973 if (element.hasStatusElement()) 11974 composeEnum(t, "TestReport", "status", element.getStatusElement(), -1); 11975 if (element.hasTestScript()) 11976 composeReference(t, "TestReport", "testScript", element.getTestScript(), -1); 11977 if (element.hasResultElement()) 11978 composeEnum(t, "TestReport", "result", element.getResultElement(), -1); 11979 if (element.hasScoreElement()) 11980 composeDecimal(t, "TestReport", "score", element.getScoreElement(), -1); 11981 if (element.hasTesterElement()) 11982 composeString(t, "TestReport", "tester", element.getTesterElement(), -1); 11983 if (element.hasIssuedElement()) 11984 composeDateTime(t, "TestReport", "issued", element.getIssuedElement(), -1); 11985 for (int i = 0; i < element.getParticipant().size(); i++) 11986 composeTestReportTestReportParticipantComponent(t, "TestReport", "participant", element.getParticipant().get(i), i); 11987 if (element.hasSetup()) 11988 composeTestReportTestReportSetupComponent(t, "TestReport", "setup", element.getSetup(), -1); 11989 for (int i = 0; i < element.getTest().size(); i++) 11990 composeTestReportTestReportTestComponent(t, "TestReport", "test", element.getTest().get(i), i); 11991 if (element.hasTeardown()) 11992 composeTestReportTestReportTeardownComponent(t, "TestReport", "teardown", element.getTeardown(), -1); 11993 } 11994 11995 protected void composeTestReportTestReportParticipantComponent(Complex parent, String parentType, String name, TestReport.TestReportParticipantComponent element, int index) { 11996 if (element == null) 11997 return; 11998 Complex t; 11999 if (Utilities.noString(parentType)) 12000 t = parent; 12001 else { 12002 t = parent.predicate("fhir:"+parentType+'.'+name); 12003 } 12004 composeBackboneElement(t, "participant", name, element, index); 12005 if (element.hasTypeElement()) 12006 composeEnum(t, "TestReport", "type", element.getTypeElement(), -1); 12007 if (element.hasUriElement()) 12008 composeUri(t, "TestReport", "uri", element.getUriElement(), -1); 12009 if (element.hasDisplayElement()) 12010 composeString(t, "TestReport", "display", element.getDisplayElement(), -1); 12011 } 12012 12013 protected void composeTestReportTestReportSetupComponent(Complex parent, String parentType, String name, TestReport.TestReportSetupComponent element, int index) { 12014 if (element == null) 12015 return; 12016 Complex t; 12017 if (Utilities.noString(parentType)) 12018 t = parent; 12019 else { 12020 t = parent.predicate("fhir:"+parentType+'.'+name); 12021 } 12022 composeBackboneElement(t, "setup", name, element, index); 12023 for (int i = 0; i < element.getAction().size(); i++) 12024 composeTestReportSetupActionComponent(t, "TestReport", "action", element.getAction().get(i), i); 12025 } 12026 12027 protected void composeTestReportSetupActionComponent(Complex parent, String parentType, String name, TestReport.SetupActionComponent element, int index) { 12028 if (element == null) 12029 return; 12030 Complex t; 12031 if (Utilities.noString(parentType)) 12032 t = parent; 12033 else { 12034 t = parent.predicate("fhir:"+parentType+'.'+name); 12035 } 12036 composeBackboneElement(t, "action", name, element, index); 12037 if (element.hasOperation()) 12038 composeTestReportSetupActionOperationComponent(t, "TestReport", "operation", element.getOperation(), -1); 12039 if (element.hasAssert()) 12040 composeTestReportSetupActionAssertComponent(t, "TestReport", "assert", element.getAssert(), -1); 12041 } 12042 12043 protected void composeTestReportSetupActionOperationComponent(Complex parent, String parentType, String name, TestReport.SetupActionOperationComponent element, int index) { 12044 if (element == null) 12045 return; 12046 Complex t; 12047 if (Utilities.noString(parentType)) 12048 t = parent; 12049 else { 12050 t = parent.predicate("fhir:"+parentType+'.'+name); 12051 } 12052 composeBackboneElement(t, "operation", name, element, index); 12053 if (element.hasResultElement()) 12054 composeEnum(t, "TestReport", "result", element.getResultElement(), -1); 12055 if (element.hasMessageElement()) 12056 composeMarkdown(t, "TestReport", "message", element.getMessageElement(), -1); 12057 if (element.hasDetailElement()) 12058 composeUri(t, "TestReport", "detail", element.getDetailElement(), -1); 12059 } 12060 12061 protected void composeTestReportSetupActionAssertComponent(Complex parent, String parentType, String name, TestReport.SetupActionAssertComponent element, int index) { 12062 if (element == null) 12063 return; 12064 Complex t; 12065 if (Utilities.noString(parentType)) 12066 t = parent; 12067 else { 12068 t = parent.predicate("fhir:"+parentType+'.'+name); 12069 } 12070 composeBackboneElement(t, "assert", name, element, index); 12071 if (element.hasResultElement()) 12072 composeEnum(t, "TestReport", "result", element.getResultElement(), -1); 12073 if (element.hasMessageElement()) 12074 composeMarkdown(t, "TestReport", "message", element.getMessageElement(), -1); 12075 if (element.hasDetailElement()) 12076 composeString(t, "TestReport", "detail", element.getDetailElement(), -1); 12077 } 12078 12079 protected void composeTestReportTestReportTestComponent(Complex parent, String parentType, String name, TestReport.TestReportTestComponent element, int index) { 12080 if (element == null) 12081 return; 12082 Complex t; 12083 if (Utilities.noString(parentType)) 12084 t = parent; 12085 else { 12086 t = parent.predicate("fhir:"+parentType+'.'+name); 12087 } 12088 composeBackboneElement(t, "test", name, element, index); 12089 if (element.hasNameElement()) 12090 composeString(t, "TestReport", "name", element.getNameElement(), -1); 12091 if (element.hasDescriptionElement()) 12092 composeString(t, "TestReport", "description", element.getDescriptionElement(), -1); 12093 for (int i = 0; i < element.getAction().size(); i++) 12094 composeTestReportTestActionComponent(t, "TestReport", "action", element.getAction().get(i), i); 12095 } 12096 12097 protected void composeTestReportTestActionComponent(Complex parent, String parentType, String name, TestReport.TestActionComponent element, int index) { 12098 if (element == null) 12099 return; 12100 Complex t; 12101 if (Utilities.noString(parentType)) 12102 t = parent; 12103 else { 12104 t = parent.predicate("fhir:"+parentType+'.'+name); 12105 } 12106 composeBackboneElement(t, "action", name, element, index); 12107 if (element.hasOperation()) 12108 composeTestReportSetupActionOperationComponent(t, "TestReport", "operation", element.getOperation(), -1); 12109 if (element.hasAssert()) 12110 composeTestReportSetupActionAssertComponent(t, "TestReport", "assert", element.getAssert(), -1); 12111 } 12112 12113 protected void composeTestReportTestReportTeardownComponent(Complex parent, String parentType, String name, TestReport.TestReportTeardownComponent element, int index) { 12114 if (element == null) 12115 return; 12116 Complex t; 12117 if (Utilities.noString(parentType)) 12118 t = parent; 12119 else { 12120 t = parent.predicate("fhir:"+parentType+'.'+name); 12121 } 12122 composeBackboneElement(t, "teardown", name, element, index); 12123 for (int i = 0; i < element.getAction().size(); i++) 12124 composeTestReportTeardownActionComponent(t, "TestReport", "action", element.getAction().get(i), i); 12125 } 12126 12127 protected void composeTestReportTeardownActionComponent(Complex parent, String parentType, String name, TestReport.TeardownActionComponent element, int index) { 12128 if (element == null) 12129 return; 12130 Complex t; 12131 if (Utilities.noString(parentType)) 12132 t = parent; 12133 else { 12134 t = parent.predicate("fhir:"+parentType+'.'+name); 12135 } 12136 composeBackboneElement(t, "action", name, element, index); 12137 if (element.hasOperation()) 12138 composeTestReportSetupActionOperationComponent(t, "TestReport", "operation", element.getOperation(), -1); 12139 } 12140 12141 protected void composeTestScript(Complex parent, String parentType, String name, TestScript element, int index) { 12142 if (element == null) 12143 return; 12144 Complex t; 12145 if (Utilities.noString(parentType)) 12146 t = parent; 12147 else { 12148 t = parent.predicate("fhir:"+parentType+'.'+name); 12149 } 12150 composeDomainResource(t, "TestScript", name, element, index); 12151 if (element.hasUrlElement()) 12152 composeUri(t, "TestScript", "url", element.getUrlElement(), -1); 12153 if (element.hasIdentifier()) 12154 composeIdentifier(t, "TestScript", "identifier", element.getIdentifier(), -1); 12155 if (element.hasVersionElement()) 12156 composeString(t, "TestScript", "version", element.getVersionElement(), -1); 12157 if (element.hasNameElement()) 12158 composeString(t, "TestScript", "name", element.getNameElement(), -1); 12159 if (element.hasTitleElement()) 12160 composeString(t, "TestScript", "title", element.getTitleElement(), -1); 12161 if (element.hasStatusElement()) 12162 composeEnum(t, "TestScript", "status", element.getStatusElement(), -1); 12163 if (element.hasExperimentalElement()) 12164 composeBoolean(t, "TestScript", "experimental", element.getExperimentalElement(), -1); 12165 if (element.hasDateElement()) 12166 composeDateTime(t, "TestScript", "date", element.getDateElement(), -1); 12167 if (element.hasPublisherElement()) 12168 composeString(t, "TestScript", "publisher", element.getPublisherElement(), -1); 12169 for (int i = 0; i < element.getContact().size(); i++) 12170 composeContactDetail(t, "TestScript", "contact", element.getContact().get(i), i); 12171 if (element.hasDescriptionElement()) 12172 composeMarkdown(t, "TestScript", "description", element.getDescriptionElement(), -1); 12173 for (int i = 0; i < element.getUseContext().size(); i++) 12174 composeUsageContext(t, "TestScript", "useContext", element.getUseContext().get(i), i); 12175 for (int i = 0; i < element.getJurisdiction().size(); i++) 12176 composeCodeableConcept(t, "TestScript", "jurisdiction", element.getJurisdiction().get(i), i); 12177 if (element.hasPurposeElement()) 12178 composeMarkdown(t, "TestScript", "purpose", element.getPurposeElement(), -1); 12179 if (element.hasCopyrightElement()) 12180 composeMarkdown(t, "TestScript", "copyright", element.getCopyrightElement(), -1); 12181 for (int i = 0; i < element.getOrigin().size(); i++) 12182 composeTestScriptTestScriptOriginComponent(t, "TestScript", "origin", element.getOrigin().get(i), i); 12183 for (int i = 0; i < element.getDestination().size(); i++) 12184 composeTestScriptTestScriptDestinationComponent(t, "TestScript", "destination", element.getDestination().get(i), i); 12185 if (element.hasMetadata()) 12186 composeTestScriptTestScriptMetadataComponent(t, "TestScript", "metadata", element.getMetadata(), -1); 12187 for (int i = 0; i < element.getFixture().size(); i++) 12188 composeTestScriptTestScriptFixtureComponent(t, "TestScript", "fixture", element.getFixture().get(i), i); 12189 for (int i = 0; i < element.getProfile().size(); i++) 12190 composeReference(t, "TestScript", "profile", element.getProfile().get(i), i); 12191 for (int i = 0; i < element.getVariable().size(); i++) 12192 composeTestScriptTestScriptVariableComponent(t, "TestScript", "variable", element.getVariable().get(i), i); 12193 for (int i = 0; i < element.getRule().size(); i++) 12194 composeTestScriptTestScriptRuleComponent(t, "TestScript", "rule", element.getRule().get(i), i); 12195 for (int i = 0; i < element.getRuleset().size(); i++) 12196 composeTestScriptTestScriptRulesetComponent(t, "TestScript", "ruleset", element.getRuleset().get(i), i); 12197 if (element.hasSetup()) 12198 composeTestScriptTestScriptSetupComponent(t, "TestScript", "setup", element.getSetup(), -1); 12199 for (int i = 0; i < element.getTest().size(); i++) 12200 composeTestScriptTestScriptTestComponent(t, "TestScript", "test", element.getTest().get(i), i); 12201 if (element.hasTeardown()) 12202 composeTestScriptTestScriptTeardownComponent(t, "TestScript", "teardown", element.getTeardown(), -1); 12203 } 12204 12205 protected void composeTestScriptTestScriptOriginComponent(Complex parent, String parentType, String name, TestScript.TestScriptOriginComponent element, int index) { 12206 if (element == null) 12207 return; 12208 Complex t; 12209 if (Utilities.noString(parentType)) 12210 t = parent; 12211 else { 12212 t = parent.predicate("fhir:"+parentType+'.'+name); 12213 } 12214 composeBackboneElement(t, "origin", name, element, index); 12215 if (element.hasIndexElement()) 12216 composeInteger(t, "TestScript", "index", element.getIndexElement(), -1); 12217 if (element.hasProfile()) 12218 composeCoding(t, "TestScript", "profile", element.getProfile(), -1); 12219 } 12220 12221 protected void composeTestScriptTestScriptDestinationComponent(Complex parent, String parentType, String name, TestScript.TestScriptDestinationComponent element, int index) { 12222 if (element == null) 12223 return; 12224 Complex t; 12225 if (Utilities.noString(parentType)) 12226 t = parent; 12227 else { 12228 t = parent.predicate("fhir:"+parentType+'.'+name); 12229 } 12230 composeBackboneElement(t, "destination", name, element, index); 12231 if (element.hasIndexElement()) 12232 composeInteger(t, "TestScript", "index", element.getIndexElement(), -1); 12233 if (element.hasProfile()) 12234 composeCoding(t, "TestScript", "profile", element.getProfile(), -1); 12235 } 12236 12237 protected void composeTestScriptTestScriptMetadataComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataComponent element, int index) { 12238 if (element == null) 12239 return; 12240 Complex t; 12241 if (Utilities.noString(parentType)) 12242 t = parent; 12243 else { 12244 t = parent.predicate("fhir:"+parentType+'.'+name); 12245 } 12246 composeBackboneElement(t, "metadata", name, element, index); 12247 for (int i = 0; i < element.getLink().size(); i++) 12248 composeTestScriptTestScriptMetadataLinkComponent(t, "TestScript", "link", element.getLink().get(i), i); 12249 for (int i = 0; i < element.getCapability().size(); i++) 12250 composeTestScriptTestScriptMetadataCapabilityComponent(t, "TestScript", "capability", element.getCapability().get(i), i); 12251 } 12252 12253 protected void composeTestScriptTestScriptMetadataLinkComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataLinkComponent element, int index) { 12254 if (element == null) 12255 return; 12256 Complex t; 12257 if (Utilities.noString(parentType)) 12258 t = parent; 12259 else { 12260 t = parent.predicate("fhir:"+parentType+'.'+name); 12261 } 12262 composeBackboneElement(t, "link", name, element, index); 12263 if (element.hasUrlElement()) 12264 composeUri(t, "TestScript", "url", element.getUrlElement(), -1); 12265 if (element.hasDescriptionElement()) 12266 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 12267 } 12268 12269 protected void composeTestScriptTestScriptMetadataCapabilityComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataCapabilityComponent element, int index) { 12270 if (element == null) 12271 return; 12272 Complex t; 12273 if (Utilities.noString(parentType)) 12274 t = parent; 12275 else { 12276 t = parent.predicate("fhir:"+parentType+'.'+name); 12277 } 12278 composeBackboneElement(t, "capability", name, element, index); 12279 if (element.hasRequiredElement()) 12280 composeBoolean(t, "TestScript", "required", element.getRequiredElement(), -1); 12281 if (element.hasValidatedElement()) 12282 composeBoolean(t, "TestScript", "validated", element.getValidatedElement(), -1); 12283 if (element.hasDescriptionElement()) 12284 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 12285 for (int i = 0; i < element.getOrigin().size(); i++) 12286 composeInteger(t, "TestScript", "origin", element.getOrigin().get(i), i); 12287 if (element.hasDestinationElement()) 12288 composeInteger(t, "TestScript", "destination", element.getDestinationElement(), -1); 12289 for (int i = 0; i < element.getLink().size(); i++) 12290 composeUri(t, "TestScript", "link", element.getLink().get(i), i); 12291 if (element.hasCapabilities()) 12292 composeReference(t, "TestScript", "capabilities", element.getCapabilities(), -1); 12293 } 12294 12295 protected void composeTestScriptTestScriptFixtureComponent(Complex parent, String parentType, String name, TestScript.TestScriptFixtureComponent element, int index) { 12296 if (element == null) 12297 return; 12298 Complex t; 12299 if (Utilities.noString(parentType)) 12300 t = parent; 12301 else { 12302 t = parent.predicate("fhir:"+parentType+'.'+name); 12303 } 12304 composeBackboneElement(t, "fixture", name, element, index); 12305 if (element.hasAutocreateElement()) 12306 composeBoolean(t, "TestScript", "autocreate", element.getAutocreateElement(), -1); 12307 if (element.hasAutodeleteElement()) 12308 composeBoolean(t, "TestScript", "autodelete", element.getAutodeleteElement(), -1); 12309 if (element.hasResource()) 12310 composeReference(t, "TestScript", "resource", element.getResource(), -1); 12311 } 12312 12313 protected void composeTestScriptTestScriptVariableComponent(Complex parent, String parentType, String name, TestScript.TestScriptVariableComponent element, int index) { 12314 if (element == null) 12315 return; 12316 Complex t; 12317 if (Utilities.noString(parentType)) 12318 t = parent; 12319 else { 12320 t = parent.predicate("fhir:"+parentType+'.'+name); 12321 } 12322 composeBackboneElement(t, "variable", name, element, index); 12323 if (element.hasNameElement()) 12324 composeString(t, "TestScript", "name", element.getNameElement(), -1); 12325 if (element.hasDefaultValueElement()) 12326 composeString(t, "TestScript", "defaultValue", element.getDefaultValueElement(), -1); 12327 if (element.hasDescriptionElement()) 12328 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 12329 if (element.hasExpressionElement()) 12330 composeString(t, "TestScript", "expression", element.getExpressionElement(), -1); 12331 if (element.hasHeaderFieldElement()) 12332 composeString(t, "TestScript", "headerField", element.getHeaderFieldElement(), -1); 12333 if (element.hasHintElement()) 12334 composeString(t, "TestScript", "hint", element.getHintElement(), -1); 12335 if (element.hasPathElement()) 12336 composeString(t, "TestScript", "path", element.getPathElement(), -1); 12337 if (element.hasSourceIdElement()) 12338 composeId(t, "TestScript", "sourceId", element.getSourceIdElement(), -1); 12339 } 12340 12341 protected void composeTestScriptTestScriptRuleComponent(Complex parent, String parentType, String name, TestScript.TestScriptRuleComponent element, int index) { 12342 if (element == null) 12343 return; 12344 Complex t; 12345 if (Utilities.noString(parentType)) 12346 t = parent; 12347 else { 12348 t = parent.predicate("fhir:"+parentType+'.'+name); 12349 } 12350 composeBackboneElement(t, "rule", name, element, index); 12351 if (element.hasResource()) 12352 composeReference(t, "TestScript", "resource", element.getResource(), -1); 12353 for (int i = 0; i < element.getParam().size(); i++) 12354 composeTestScriptRuleParamComponent(t, "TestScript", "param", element.getParam().get(i), i); 12355 } 12356 12357 protected void composeTestScriptRuleParamComponent(Complex parent, String parentType, String name, TestScript.RuleParamComponent element, int index) { 12358 if (element == null) 12359 return; 12360 Complex t; 12361 if (Utilities.noString(parentType)) 12362 t = parent; 12363 else { 12364 t = parent.predicate("fhir:"+parentType+'.'+name); 12365 } 12366 composeBackboneElement(t, "param", name, element, index); 12367 if (element.hasNameElement()) 12368 composeString(t, "TestScript", "name", element.getNameElement(), -1); 12369 if (element.hasValueElement()) 12370 composeString(t, "TestScript", "value", element.getValueElement(), -1); 12371 } 12372 12373 protected void composeTestScriptTestScriptRulesetComponent(Complex parent, String parentType, String name, TestScript.TestScriptRulesetComponent element, int index) { 12374 if (element == null) 12375 return; 12376 Complex t; 12377 if (Utilities.noString(parentType)) 12378 t = parent; 12379 else { 12380 t = parent.predicate("fhir:"+parentType+'.'+name); 12381 } 12382 composeBackboneElement(t, "ruleset", name, element, index); 12383 if (element.hasResource()) 12384 composeReference(t, "TestScript", "resource", element.getResource(), -1); 12385 for (int i = 0; i < element.getRule().size(); i++) 12386 composeTestScriptRulesetRuleComponent(t, "TestScript", "rule", element.getRule().get(i), i); 12387 } 12388 12389 protected void composeTestScriptRulesetRuleComponent(Complex parent, String parentType, String name, TestScript.RulesetRuleComponent element, int index) { 12390 if (element == null) 12391 return; 12392 Complex t; 12393 if (Utilities.noString(parentType)) 12394 t = parent; 12395 else { 12396 t = parent.predicate("fhir:"+parentType+'.'+name); 12397 } 12398 composeBackboneElement(t, "rule", name, element, index); 12399 if (element.hasRuleIdElement()) 12400 composeId(t, "TestScript", "ruleId", element.getRuleIdElement(), -1); 12401 for (int i = 0; i < element.getParam().size(); i++) 12402 composeTestScriptRulesetRuleParamComponent(t, "TestScript", "param", element.getParam().get(i), i); 12403 } 12404 12405 protected void composeTestScriptRulesetRuleParamComponent(Complex parent, String parentType, String name, TestScript.RulesetRuleParamComponent element, int index) { 12406 if (element == null) 12407 return; 12408 Complex t; 12409 if (Utilities.noString(parentType)) 12410 t = parent; 12411 else { 12412 t = parent.predicate("fhir:"+parentType+'.'+name); 12413 } 12414 composeBackboneElement(t, "param", name, element, index); 12415 if (element.hasNameElement()) 12416 composeString(t, "TestScript", "name", element.getNameElement(), -1); 12417 if (element.hasValueElement()) 12418 composeString(t, "TestScript", "value", element.getValueElement(), -1); 12419 } 12420 12421 protected void composeTestScriptTestScriptSetupComponent(Complex parent, String parentType, String name, TestScript.TestScriptSetupComponent element, int index) { 12422 if (element == null) 12423 return; 12424 Complex t; 12425 if (Utilities.noString(parentType)) 12426 t = parent; 12427 else { 12428 t = parent.predicate("fhir:"+parentType+'.'+name); 12429 } 12430 composeBackboneElement(t, "setup", name, element, index); 12431 for (int i = 0; i < element.getAction().size(); i++) 12432 composeTestScriptSetupActionComponent(t, "TestScript", "action", element.getAction().get(i), i); 12433 } 12434 12435 protected void composeTestScriptSetupActionComponent(Complex parent, String parentType, String name, TestScript.SetupActionComponent element, int index) { 12436 if (element == null) 12437 return; 12438 Complex t; 12439 if (Utilities.noString(parentType)) 12440 t = parent; 12441 else { 12442 t = parent.predicate("fhir:"+parentType+'.'+name); 12443 } 12444 composeBackboneElement(t, "action", name, element, index); 12445 if (element.hasOperation()) 12446 composeTestScriptSetupActionOperationComponent(t, "TestScript", "operation", element.getOperation(), -1); 12447 if (element.hasAssert()) 12448 composeTestScriptSetupActionAssertComponent(t, "TestScript", "assert", element.getAssert(), -1); 12449 } 12450 12451 protected void composeTestScriptSetupActionOperationComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationComponent element, int index) { 12452 if (element == null) 12453 return; 12454 Complex t; 12455 if (Utilities.noString(parentType)) 12456 t = parent; 12457 else { 12458 t = parent.predicate("fhir:"+parentType+'.'+name); 12459 } 12460 composeBackboneElement(t, "operation", name, element, index); 12461 if (element.hasType()) 12462 composeCoding(t, "TestScript", "type", element.getType(), -1); 12463 if (element.hasResourceElement()) 12464 composeCode(t, "TestScript", "resource", element.getResourceElement(), -1); 12465 if (element.hasLabelElement()) 12466 composeString(t, "TestScript", "label", element.getLabelElement(), -1); 12467 if (element.hasDescriptionElement()) 12468 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 12469 if (element.hasAcceptElement()) 12470 composeEnum(t, "TestScript", "accept", element.getAcceptElement(), -1); 12471 if (element.hasContentTypeElement()) 12472 composeEnum(t, "TestScript", "contentType", element.getContentTypeElement(), -1); 12473 if (element.hasDestinationElement()) 12474 composeInteger(t, "TestScript", "destination", element.getDestinationElement(), -1); 12475 if (element.hasEncodeRequestUrlElement()) 12476 composeBoolean(t, "TestScript", "encodeRequestUrl", element.getEncodeRequestUrlElement(), -1); 12477 if (element.hasOriginElement()) 12478 composeInteger(t, "TestScript", "origin", element.getOriginElement(), -1); 12479 if (element.hasParamsElement()) 12480 composeString(t, "TestScript", "params", element.getParamsElement(), -1); 12481 for (int i = 0; i < element.getRequestHeader().size(); i++) 12482 composeTestScriptSetupActionOperationRequestHeaderComponent(t, "TestScript", "requestHeader", element.getRequestHeader().get(i), i); 12483 if (element.hasRequestIdElement()) 12484 composeId(t, "TestScript", "requestId", element.getRequestIdElement(), -1); 12485 if (element.hasResponseIdElement()) 12486 composeId(t, "TestScript", "responseId", element.getResponseIdElement(), -1); 12487 if (element.hasSourceIdElement()) 12488 composeId(t, "TestScript", "sourceId", element.getSourceIdElement(), -1); 12489 if (element.hasTargetIdElement()) 12490 composeId(t, "TestScript", "targetId", element.getTargetIdElement(), -1); 12491 if (element.hasUrlElement()) 12492 composeString(t, "TestScript", "url", element.getUrlElement(), -1); 12493 } 12494 12495 protected void composeTestScriptSetupActionOperationRequestHeaderComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationRequestHeaderComponent element, int index) { 12496 if (element == null) 12497 return; 12498 Complex t; 12499 if (Utilities.noString(parentType)) 12500 t = parent; 12501 else { 12502 t = parent.predicate("fhir:"+parentType+'.'+name); 12503 } 12504 composeBackboneElement(t, "requestHeader", name, element, index); 12505 if (element.hasFieldElement()) 12506 composeString(t, "TestScript", "field", element.getFieldElement(), -1); 12507 if (element.hasValueElement()) 12508 composeString(t, "TestScript", "value", element.getValueElement(), -1); 12509 } 12510 12511 protected void composeTestScriptSetupActionAssertComponent(Complex parent, String parentType, String name, TestScript.SetupActionAssertComponent element, int index) { 12512 if (element == null) 12513 return; 12514 Complex t; 12515 if (Utilities.noString(parentType)) 12516 t = parent; 12517 else { 12518 t = parent.predicate("fhir:"+parentType+'.'+name); 12519 } 12520 composeBackboneElement(t, "assert", name, element, index); 12521 if (element.hasLabelElement()) 12522 composeString(t, "TestScript", "label", element.getLabelElement(), -1); 12523 if (element.hasDescriptionElement()) 12524 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 12525 if (element.hasDirectionElement()) 12526 composeEnum(t, "TestScript", "direction", element.getDirectionElement(), -1); 12527 if (element.hasCompareToSourceIdElement()) 12528 composeString(t, "TestScript", "compareToSourceId", element.getCompareToSourceIdElement(), -1); 12529 if (element.hasCompareToSourceExpressionElement()) 12530 composeString(t, "TestScript", "compareToSourceExpression", element.getCompareToSourceExpressionElement(), -1); 12531 if (element.hasCompareToSourcePathElement()) 12532 composeString(t, "TestScript", "compareToSourcePath", element.getCompareToSourcePathElement(), -1); 12533 if (element.hasContentTypeElement()) 12534 composeEnum(t, "TestScript", "contentType", element.getContentTypeElement(), -1); 12535 if (element.hasExpressionElement()) 12536 composeString(t, "TestScript", "expression", element.getExpressionElement(), -1); 12537 if (element.hasHeaderFieldElement()) 12538 composeString(t, "TestScript", "headerField", element.getHeaderFieldElement(), -1); 12539 if (element.hasMinimumIdElement()) 12540 composeString(t, "TestScript", "minimumId", element.getMinimumIdElement(), -1); 12541 if (element.hasNavigationLinksElement()) 12542 composeBoolean(t, "TestScript", "navigationLinks", element.getNavigationLinksElement(), -1); 12543 if (element.hasOperatorElement()) 12544 composeEnum(t, "TestScript", "operator", element.getOperatorElement(), -1); 12545 if (element.hasPathElement()) 12546 composeString(t, "TestScript", "path", element.getPathElement(), -1); 12547 if (element.hasRequestMethodElement()) 12548 composeEnum(t, "TestScript", "requestMethod", element.getRequestMethodElement(), -1); 12549 if (element.hasRequestURLElement()) 12550 composeString(t, "TestScript", "requestURL", element.getRequestURLElement(), -1); 12551 if (element.hasResourceElement()) 12552 composeCode(t, "TestScript", "resource", element.getResourceElement(), -1); 12553 if (element.hasResponseElement()) 12554 composeEnum(t, "TestScript", "response", element.getResponseElement(), -1); 12555 if (element.hasResponseCodeElement()) 12556 composeString(t, "TestScript", "responseCode", element.getResponseCodeElement(), -1); 12557 if (element.hasRule()) 12558 composeTestScriptActionAssertRuleComponent(t, "TestScript", "rule", element.getRule(), -1); 12559 if (element.hasRuleset()) 12560 composeTestScriptActionAssertRulesetComponent(t, "TestScript", "ruleset", element.getRuleset(), -1); 12561 if (element.hasSourceIdElement()) 12562 composeId(t, "TestScript", "sourceId", element.getSourceIdElement(), -1); 12563 if (element.hasValidateProfileIdElement()) 12564 composeId(t, "TestScript", "validateProfileId", element.getValidateProfileIdElement(), -1); 12565 if (element.hasValueElement()) 12566 composeString(t, "TestScript", "value", element.getValueElement(), -1); 12567 if (element.hasWarningOnlyElement()) 12568 composeBoolean(t, "TestScript", "warningOnly", element.getWarningOnlyElement(), -1); 12569 } 12570 12571 protected void composeTestScriptActionAssertRuleComponent(Complex parent, String parentType, String name, TestScript.ActionAssertRuleComponent element, int index) { 12572 if (element == null) 12573 return; 12574 Complex t; 12575 if (Utilities.noString(parentType)) 12576 t = parent; 12577 else { 12578 t = parent.predicate("fhir:"+parentType+'.'+name); 12579 } 12580 composeBackboneElement(t, "rule", name, element, index); 12581 if (element.hasRuleIdElement()) 12582 composeId(t, "TestScript", "ruleId", element.getRuleIdElement(), -1); 12583 for (int i = 0; i < element.getParam().size(); i++) 12584 composeTestScriptActionAssertRuleParamComponent(t, "TestScript", "param", element.getParam().get(i), i); 12585 } 12586 12587 protected void composeTestScriptActionAssertRuleParamComponent(Complex parent, String parentType, String name, TestScript.ActionAssertRuleParamComponent element, int index) { 12588 if (element == null) 12589 return; 12590 Complex t; 12591 if (Utilities.noString(parentType)) 12592 t = parent; 12593 else { 12594 t = parent.predicate("fhir:"+parentType+'.'+name); 12595 } 12596 composeBackboneElement(t, "param", name, element, index); 12597 if (element.hasNameElement()) 12598 composeString(t, "TestScript", "name", element.getNameElement(), -1); 12599 if (element.hasValueElement()) 12600 composeString(t, "TestScript", "value", element.getValueElement(), -1); 12601 } 12602 12603 protected void composeTestScriptActionAssertRulesetComponent(Complex parent, String parentType, String name, TestScript.ActionAssertRulesetComponent element, int index) { 12604 if (element == null) 12605 return; 12606 Complex t; 12607 if (Utilities.noString(parentType)) 12608 t = parent; 12609 else { 12610 t = parent.predicate("fhir:"+parentType+'.'+name); 12611 } 12612 composeBackboneElement(t, "ruleset", name, element, index); 12613 if (element.hasRulesetIdElement()) 12614 composeId(t, "TestScript", "rulesetId", element.getRulesetIdElement(), -1); 12615 for (int i = 0; i < element.getRule().size(); i++) 12616 composeTestScriptActionAssertRulesetRuleComponent(t, "TestScript", "rule", element.getRule().get(i), i); 12617 } 12618 12619 protected void composeTestScriptActionAssertRulesetRuleComponent(Complex parent, String parentType, String name, TestScript.ActionAssertRulesetRuleComponent element, int index) { 12620 if (element == null) 12621 return; 12622 Complex t; 12623 if (Utilities.noString(parentType)) 12624 t = parent; 12625 else { 12626 t = parent.predicate("fhir:"+parentType+'.'+name); 12627 } 12628 composeBackboneElement(t, "rule", name, element, index); 12629 if (element.hasRuleIdElement()) 12630 composeId(t, "TestScript", "ruleId", element.getRuleIdElement(), -1); 12631 for (int i = 0; i < element.getParam().size(); i++) 12632 composeTestScriptActionAssertRulesetRuleParamComponent(t, "TestScript", "param", element.getParam().get(i), i); 12633 } 12634 12635 protected void composeTestScriptActionAssertRulesetRuleParamComponent(Complex parent, String parentType, String name, TestScript.ActionAssertRulesetRuleParamComponent element, int index) { 12636 if (element == null) 12637 return; 12638 Complex t; 12639 if (Utilities.noString(parentType)) 12640 t = parent; 12641 else { 12642 t = parent.predicate("fhir:"+parentType+'.'+name); 12643 } 12644 composeBackboneElement(t, "param", name, element, index); 12645 if (element.hasNameElement()) 12646 composeString(t, "TestScript", "name", element.getNameElement(), -1); 12647 if (element.hasValueElement()) 12648 composeString(t, "TestScript", "value", element.getValueElement(), -1); 12649 } 12650 12651 protected void composeTestScriptTestScriptTestComponent(Complex parent, String parentType, String name, TestScript.TestScriptTestComponent element, int index) { 12652 if (element == null) 12653 return; 12654 Complex t; 12655 if (Utilities.noString(parentType)) 12656 t = parent; 12657 else { 12658 t = parent.predicate("fhir:"+parentType+'.'+name); 12659 } 12660 composeBackboneElement(t, "test", name, element, index); 12661 if (element.hasNameElement()) 12662 composeString(t, "TestScript", "name", element.getNameElement(), -1); 12663 if (element.hasDescriptionElement()) 12664 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 12665 for (int i = 0; i < element.getAction().size(); i++) 12666 composeTestScriptTestActionComponent(t, "TestScript", "action", element.getAction().get(i), i); 12667 } 12668 12669 protected void composeTestScriptTestActionComponent(Complex parent, String parentType, String name, TestScript.TestActionComponent element, int index) { 12670 if (element == null) 12671 return; 12672 Complex t; 12673 if (Utilities.noString(parentType)) 12674 t = parent; 12675 else { 12676 t = parent.predicate("fhir:"+parentType+'.'+name); 12677 } 12678 composeBackboneElement(t, "action", name, element, index); 12679 if (element.hasOperation()) 12680 composeTestScriptSetupActionOperationComponent(t, "TestScript", "operation", element.getOperation(), -1); 12681 if (element.hasAssert()) 12682 composeTestScriptSetupActionAssertComponent(t, "TestScript", "assert", element.getAssert(), -1); 12683 } 12684 12685 protected void composeTestScriptTestScriptTeardownComponent(Complex parent, String parentType, String name, TestScript.TestScriptTeardownComponent element, int index) { 12686 if (element == null) 12687 return; 12688 Complex t; 12689 if (Utilities.noString(parentType)) 12690 t = parent; 12691 else { 12692 t = parent.predicate("fhir:"+parentType+'.'+name); 12693 } 12694 composeBackboneElement(t, "teardown", name, element, index); 12695 for (int i = 0; i < element.getAction().size(); i++) 12696 composeTestScriptTeardownActionComponent(t, "TestScript", "action", element.getAction().get(i), i); 12697 } 12698 12699 protected void composeTestScriptTeardownActionComponent(Complex parent, String parentType, String name, TestScript.TeardownActionComponent element, int index) { 12700 if (element == null) 12701 return; 12702 Complex t; 12703 if (Utilities.noString(parentType)) 12704 t = parent; 12705 else { 12706 t = parent.predicate("fhir:"+parentType+'.'+name); 12707 } 12708 composeBackboneElement(t, "action", name, element, index); 12709 if (element.hasOperation()) 12710 composeTestScriptSetupActionOperationComponent(t, "TestScript", "operation", element.getOperation(), -1); 12711 } 12712 12713 protected void composeValueSet(Complex parent, String parentType, String name, ValueSet element, int index) { 12714 if (element == null) 12715 return; 12716 Complex t; 12717 if (Utilities.noString(parentType)) 12718 t = parent; 12719 else { 12720 t = parent.predicate("fhir:"+parentType+'.'+name); 12721 } 12722 composeDomainResource(t, "ValueSet", name, element, index); 12723 if (element.hasUrlElement()) 12724 composeUri(t, "ValueSet", "url", element.getUrlElement(), -1); 12725 for (int i = 0; i < element.getIdentifier().size(); i++) 12726 composeIdentifier(t, "ValueSet", "identifier", element.getIdentifier().get(i), i); 12727 if (element.hasVersionElement()) 12728 composeString(t, "ValueSet", "version", element.getVersionElement(), -1); 12729 if (element.hasNameElement()) 12730 composeString(t, "ValueSet", "name", element.getNameElement(), -1); 12731 if (element.hasTitleElement()) 12732 composeString(t, "ValueSet", "title", element.getTitleElement(), -1); 12733 if (element.hasStatusElement()) 12734 composeEnum(t, "ValueSet", "status", element.getStatusElement(), -1); 12735 if (element.hasExperimentalElement()) 12736 composeBoolean(t, "ValueSet", "experimental", element.getExperimentalElement(), -1); 12737 if (element.hasDateElement()) 12738 composeDateTime(t, "ValueSet", "date", element.getDateElement(), -1); 12739 if (element.hasPublisherElement()) 12740 composeString(t, "ValueSet", "publisher", element.getPublisherElement(), -1); 12741 for (int i = 0; i < element.getContact().size(); i++) 12742 composeContactDetail(t, "ValueSet", "contact", element.getContact().get(i), i); 12743 if (element.hasDescriptionElement()) 12744 composeMarkdown(t, "ValueSet", "description", element.getDescriptionElement(), -1); 12745 for (int i = 0; i < element.getUseContext().size(); i++) 12746 composeUsageContext(t, "ValueSet", "useContext", element.getUseContext().get(i), i); 12747 for (int i = 0; i < element.getJurisdiction().size(); i++) 12748 composeCodeableConcept(t, "ValueSet", "jurisdiction", element.getJurisdiction().get(i), i); 12749 if (element.hasImmutableElement()) 12750 composeBoolean(t, "ValueSet", "immutable", element.getImmutableElement(), -1); 12751 if (element.hasPurposeElement()) 12752 composeMarkdown(t, "ValueSet", "purpose", element.getPurposeElement(), -1); 12753 if (element.hasCopyrightElement()) 12754 composeMarkdown(t, "ValueSet", "copyright", element.getCopyrightElement(), -1); 12755 if (element.hasExtensibleElement()) 12756 composeBoolean(t, "ValueSet", "extensible", element.getExtensibleElement(), -1); 12757 if (element.hasCompose()) 12758 composeValueSetValueSetComposeComponent(t, "ValueSet", "compose", element.getCompose(), -1); 12759 if (element.hasExpansion()) 12760 composeValueSetValueSetExpansionComponent(t, "ValueSet", "expansion", element.getExpansion(), -1); 12761 } 12762 12763 protected void composeValueSetValueSetComposeComponent(Complex parent, String parentType, String name, ValueSet.ValueSetComposeComponent element, int index) { 12764 if (element == null) 12765 return; 12766 Complex t; 12767 if (Utilities.noString(parentType)) 12768 t = parent; 12769 else { 12770 t = parent.predicate("fhir:"+parentType+'.'+name); 12771 } 12772 composeBackboneElement(t, "compose", name, element, index); 12773 if (element.hasLockedDateElement()) 12774 composeDate(t, "ValueSet", "lockedDate", element.getLockedDateElement(), -1); 12775 if (element.hasInactiveElement()) 12776 composeBoolean(t, "ValueSet", "inactive", element.getInactiveElement(), -1); 12777 for (int i = 0; i < element.getInclude().size(); i++) 12778 composeValueSetConceptSetComponent(t, "ValueSet", "include", element.getInclude().get(i), i); 12779 for (int i = 0; i < element.getExclude().size(); i++) 12780 composeValueSetConceptSetComponent(t, "ValueSet", "exclude", element.getExclude().get(i), i); 12781 } 12782 12783 protected void composeValueSetConceptSetComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetComponent element, int index) { 12784 if (element == null) 12785 return; 12786 Complex t; 12787 if (Utilities.noString(parentType)) 12788 t = parent; 12789 else { 12790 t = parent.predicate("fhir:"+parentType+'.'+name); 12791 } 12792 composeBackboneElement(t, "include", name, element, index); 12793 if (element.hasSystemElement()) 12794 composeUri(t, "ValueSet", "system", element.getSystemElement(), -1); 12795 if (element.hasVersionElement()) 12796 composeString(t, "ValueSet", "version", element.getVersionElement(), -1); 12797 for (int i = 0; i < element.getConcept().size(); i++) 12798 composeValueSetConceptReferenceComponent(t, "ValueSet", "concept", element.getConcept().get(i), i); 12799 for (int i = 0; i < element.getFilter().size(); i++) 12800 composeValueSetConceptSetFilterComponent(t, "ValueSet", "filter", element.getFilter().get(i), i); 12801 for (int i = 0; i < element.getValueSet().size(); i++) 12802 composeUri(t, "ValueSet", "valueSet", element.getValueSet().get(i), i); 12803 } 12804 12805 protected void composeValueSetConceptReferenceComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceComponent element, int index) { 12806 if (element == null) 12807 return; 12808 Complex t; 12809 if (Utilities.noString(parentType)) 12810 t = parent; 12811 else { 12812 t = parent.predicate("fhir:"+parentType+'.'+name); 12813 } 12814 composeBackboneElement(t, "concept", name, element, index); 12815 if (element.hasCodeElement()) 12816 composeCode(t, "ValueSet", "code", element.getCodeElement(), -1); 12817 if (element.hasDisplayElement()) 12818 composeString(t, "ValueSet", "display", element.getDisplayElement(), -1); 12819 for (int i = 0; i < element.getDesignation().size(); i++) 12820 composeValueSetConceptReferenceDesignationComponent(t, "ValueSet", "designation", element.getDesignation().get(i), i); 12821 } 12822 12823 protected void composeValueSetConceptReferenceDesignationComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceDesignationComponent element, int index) { 12824 if (element == null) 12825 return; 12826 Complex t; 12827 if (Utilities.noString(parentType)) 12828 t = parent; 12829 else { 12830 t = parent.predicate("fhir:"+parentType+'.'+name); 12831 } 12832 composeBackboneElement(t, "designation", name, element, index); 12833 if (element.hasLanguageElement()) 12834 composeCode(t, "ValueSet", "language", element.getLanguageElement(), -1); 12835 if (element.hasUse()) 12836 composeCoding(t, "ValueSet", "use", element.getUse(), -1); 12837 if (element.hasValueElement()) 12838 composeString(t, "ValueSet", "value", element.getValueElement(), -1); 12839 } 12840 12841 protected void composeValueSetConceptSetFilterComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetFilterComponent element, int index) { 12842 if (element == null) 12843 return; 12844 Complex t; 12845 if (Utilities.noString(parentType)) 12846 t = parent; 12847 else { 12848 t = parent.predicate("fhir:"+parentType+'.'+name); 12849 } 12850 composeBackboneElement(t, "filter", name, element, index); 12851 if (element.hasPropertyElement()) 12852 composeCode(t, "ValueSet", "property", element.getPropertyElement(), -1); 12853 if (element.hasOpElement()) 12854 composeEnum(t, "ValueSet", "op", element.getOpElement(), -1); 12855 if (element.hasValueElement()) 12856 composeCode(t, "ValueSet", "value", element.getValueElement(), -1); 12857 } 12858 12859 protected void composeValueSetValueSetExpansionComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionComponent element, int index) { 12860 if (element == null) 12861 return; 12862 Complex t; 12863 if (Utilities.noString(parentType)) 12864 t = parent; 12865 else { 12866 t = parent.predicate("fhir:"+parentType+'.'+name); 12867 } 12868 composeBackboneElement(t, "expansion", name, element, index); 12869 if (element.hasIdentifierElement()) 12870 composeUri(t, "ValueSet", "identifier", element.getIdentifierElement(), -1); 12871 if (element.hasTimestampElement()) 12872 composeDateTime(t, "ValueSet", "timestamp", element.getTimestampElement(), -1); 12873 if (element.hasTotalElement()) 12874 composeInteger(t, "ValueSet", "total", element.getTotalElement(), -1); 12875 if (element.hasOffsetElement()) 12876 composeInteger(t, "ValueSet", "offset", element.getOffsetElement(), -1); 12877 for (int i = 0; i < element.getParameter().size(); i++) 12878 composeValueSetValueSetExpansionParameterComponent(t, "ValueSet", "parameter", element.getParameter().get(i), i); 12879 for (int i = 0; i < element.getContains().size(); i++) 12880 composeValueSetValueSetExpansionContainsComponent(t, "ValueSet", "contains", element.getContains().get(i), i); 12881 } 12882 12883 protected void composeValueSetValueSetExpansionParameterComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionParameterComponent element, int index) { 12884 if (element == null) 12885 return; 12886 Complex t; 12887 if (Utilities.noString(parentType)) 12888 t = parent; 12889 else { 12890 t = parent.predicate("fhir:"+parentType+'.'+name); 12891 } 12892 composeBackboneElement(t, "parameter", name, element, index); 12893 if (element.hasNameElement()) 12894 composeString(t, "ValueSet", "name", element.getNameElement(), -1); 12895 if (element.hasValue()) 12896 composeType(t, "ValueSet", "value", element.getValue(), -1); 12897 } 12898 12899 protected void composeValueSetValueSetExpansionContainsComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionContainsComponent element, int index) { 12900 if (element == null) 12901 return; 12902 Complex t; 12903 if (Utilities.noString(parentType)) 12904 t = parent; 12905 else { 12906 t = parent.predicate("fhir:"+parentType+'.'+name); 12907 } 12908 composeBackboneElement(t, "contains", name, element, index); 12909 if (element.hasSystemElement()) 12910 composeUri(t, "ValueSet", "system", element.getSystemElement(), -1); 12911 if (element.hasAbstractElement()) 12912 composeBoolean(t, "ValueSet", "abstract", element.getAbstractElement(), -1); 12913 if (element.hasInactiveElement()) 12914 composeBoolean(t, "ValueSet", "inactive", element.getInactiveElement(), -1); 12915 if (element.hasVersionElement()) 12916 composeString(t, "ValueSet", "version", element.getVersionElement(), -1); 12917 if (element.hasCodeElement()) 12918 composeCode(t, "ValueSet", "code", element.getCodeElement(), -1); 12919 if (element.hasDisplayElement()) 12920 composeString(t, "ValueSet", "display", element.getDisplayElement(), -1); 12921 for (int i = 0; i < element.getDesignation().size(); i++) 12922 composeValueSetConceptReferenceDesignationComponent(t, "ValueSet", "designation", element.getDesignation().get(i), i); 12923 for (int i = 0; i < element.getContains().size(); i++) 12924 composeValueSetValueSetExpansionContainsComponent(t, "ValueSet", "contains", element.getContains().get(i), i); 12925 } 12926 12927 protected void composeVisionPrescription(Complex parent, String parentType, String name, VisionPrescription element, int index) { 12928 if (element == null) 12929 return; 12930 Complex t; 12931 if (Utilities.noString(parentType)) 12932 t = parent; 12933 else { 12934 t = parent.predicate("fhir:"+parentType+'.'+name); 12935 } 12936 composeDomainResource(t, "VisionPrescription", name, element, index); 12937 for (int i = 0; i < element.getIdentifier().size(); i++) 12938 composeIdentifier(t, "VisionPrescription", "identifier", element.getIdentifier().get(i), i); 12939 if (element.hasStatusElement()) 12940 composeEnum(t, "VisionPrescription", "status", element.getStatusElement(), -1); 12941 if (element.hasPatient()) 12942 composeReference(t, "VisionPrescription", "patient", element.getPatient(), -1); 12943 if (element.hasEncounter()) 12944 composeReference(t, "VisionPrescription", "encounter", element.getEncounter(), -1); 12945 if (element.hasDateWrittenElement()) 12946 composeDateTime(t, "VisionPrescription", "dateWritten", element.getDateWrittenElement(), -1); 12947 if (element.hasPrescriber()) 12948 composeReference(t, "VisionPrescription", "prescriber", element.getPrescriber(), -1); 12949 if (element.hasReason()) 12950 composeType(t, "VisionPrescription", "reason", element.getReason(), -1); 12951 for (int i = 0; i < element.getDispense().size(); i++) 12952 composeVisionPrescriptionVisionPrescriptionDispenseComponent(t, "VisionPrescription", "dispense", element.getDispense().get(i), i); 12953 } 12954 12955 protected void composeVisionPrescriptionVisionPrescriptionDispenseComponent(Complex parent, String parentType, String name, VisionPrescription.VisionPrescriptionDispenseComponent element, int index) { 12956 if (element == null) 12957 return; 12958 Complex t; 12959 if (Utilities.noString(parentType)) 12960 t = parent; 12961 else { 12962 t = parent.predicate("fhir:"+parentType+'.'+name); 12963 } 12964 composeBackboneElement(t, "dispense", name, element, index); 12965 if (element.hasProduct()) 12966 composeCodeableConcept(t, "VisionPrescription", "product", element.getProduct(), -1); 12967 if (element.hasEyeElement()) 12968 composeEnum(t, "VisionPrescription", "eye", element.getEyeElement(), -1); 12969 if (element.hasSphereElement()) 12970 composeDecimal(t, "VisionPrescription", "sphere", element.getSphereElement(), -1); 12971 if (element.hasCylinderElement()) 12972 composeDecimal(t, "VisionPrescription", "cylinder", element.getCylinderElement(), -1); 12973 if (element.hasAxisElement()) 12974 composeInteger(t, "VisionPrescription", "axis", element.getAxisElement(), -1); 12975 if (element.hasPrismElement()) 12976 composeDecimal(t, "VisionPrescription", "prism", element.getPrismElement(), -1); 12977 if (element.hasBaseElement()) 12978 composeEnum(t, "VisionPrescription", "base", element.getBaseElement(), -1); 12979 if (element.hasAddElement()) 12980 composeDecimal(t, "VisionPrescription", "add", element.getAddElement(), -1); 12981 if (element.hasPowerElement()) 12982 composeDecimal(t, "VisionPrescription", "power", element.getPowerElement(), -1); 12983 if (element.hasBackCurveElement()) 12984 composeDecimal(t, "VisionPrescription", "backCurve", element.getBackCurveElement(), -1); 12985 if (element.hasDiameterElement()) 12986 composeDecimal(t, "VisionPrescription", "diameter", element.getDiameterElement(), -1); 12987 if (element.hasDuration()) 12988 composeQuantity(t, "VisionPrescription", "duration", element.getDuration(), -1); 12989 if (element.hasColorElement()) 12990 composeString(t, "VisionPrescription", "color", element.getColorElement(), -1); 12991 if (element.hasBrandElement()) 12992 composeString(t, "VisionPrescription", "brand", element.getBrandElement(), -1); 12993 for (int i = 0; i < element.getNote().size(); i++) 12994 composeAnnotation(t, "VisionPrescription", "note", element.getNote().get(i), i); 12995 } 12996 12997 @Override 12998 protected void composeResource(Complex parent, Resource resource) { 12999 if (resource instanceof Parameters) 13000 composeParameters(parent, null, "Parameters", (Parameters)resource, -1); 13001 else if (resource instanceof Account) 13002 composeAccount(parent, null, "Account", (Account)resource, -1); 13003 else if (resource instanceof ActivityDefinition) 13004 composeActivityDefinition(parent, null, "ActivityDefinition", (ActivityDefinition)resource, -1); 13005 else if (resource instanceof AdverseEvent) 13006 composeAdverseEvent(parent, null, "AdverseEvent", (AdverseEvent)resource, -1); 13007 else if (resource instanceof AllergyIntolerance) 13008 composeAllergyIntolerance(parent, null, "AllergyIntolerance", (AllergyIntolerance)resource, -1); 13009 else if (resource instanceof Appointment) 13010 composeAppointment(parent, null, "Appointment", (Appointment)resource, -1); 13011 else if (resource instanceof AppointmentResponse) 13012 composeAppointmentResponse(parent, null, "AppointmentResponse", (AppointmentResponse)resource, -1); 13013 else if (resource instanceof AuditEvent) 13014 composeAuditEvent(parent, null, "AuditEvent", (AuditEvent)resource, -1); 13015 else if (resource instanceof Basic) 13016 composeBasic(parent, null, "Basic", (Basic)resource, -1); 13017 else if (resource instanceof Binary) 13018 composeBinary(parent, null, "Binary", (Binary)resource, -1); 13019 else if (resource instanceof BodySite) 13020 composeBodySite(parent, null, "BodySite", (BodySite)resource, -1); 13021 else if (resource instanceof Bundle) 13022 composeBundle(parent, null, "Bundle", (Bundle)resource, -1); 13023 else if (resource instanceof CapabilityStatement) 13024 composeCapabilityStatement(parent, null, "CapabilityStatement", (CapabilityStatement)resource, -1); 13025 else if (resource instanceof CarePlan) 13026 composeCarePlan(parent, null, "CarePlan", (CarePlan)resource, -1); 13027 else if (resource instanceof CareTeam) 13028 composeCareTeam(parent, null, "CareTeam", (CareTeam)resource, -1); 13029 else if (resource instanceof ChargeItem) 13030 composeChargeItem(parent, null, "ChargeItem", (ChargeItem)resource, -1); 13031 else if (resource instanceof Claim) 13032 composeClaim(parent, null, "Claim", (Claim)resource, -1); 13033 else if (resource instanceof ClaimResponse) 13034 composeClaimResponse(parent, null, "ClaimResponse", (ClaimResponse)resource, -1); 13035 else if (resource instanceof ClinicalImpression) 13036 composeClinicalImpression(parent, null, "ClinicalImpression", (ClinicalImpression)resource, -1); 13037 else if (resource instanceof CodeSystem) 13038 composeCodeSystem(parent, null, "CodeSystem", (CodeSystem)resource, -1); 13039 else if (resource instanceof Communication) 13040 composeCommunication(parent, null, "Communication", (Communication)resource, -1); 13041 else if (resource instanceof CommunicationRequest) 13042 composeCommunicationRequest(parent, null, "CommunicationRequest", (CommunicationRequest)resource, -1); 13043 else if (resource instanceof CompartmentDefinition) 13044 composeCompartmentDefinition(parent, null, "CompartmentDefinition", (CompartmentDefinition)resource, -1); 13045 else if (resource instanceof Composition) 13046 composeComposition(parent, null, "Composition", (Composition)resource, -1); 13047 else if (resource instanceof ConceptMap) 13048 composeConceptMap(parent, null, "ConceptMap", (ConceptMap)resource, -1); 13049 else if (resource instanceof Condition) 13050 composeCondition(parent, null, "Condition", (Condition)resource, -1); 13051 else if (resource instanceof Consent) 13052 composeConsent(parent, null, "Consent", (Consent)resource, -1); 13053 else if (resource instanceof Contract) 13054 composeContract(parent, null, "Contract", (Contract)resource, -1); 13055 else if (resource instanceof Coverage) 13056 composeCoverage(parent, null, "Coverage", (Coverage)resource, -1); 13057 else if (resource instanceof DataElement) 13058 composeDataElement(parent, null, "DataElement", (DataElement)resource, -1); 13059 else if (resource instanceof DetectedIssue) 13060 composeDetectedIssue(parent, null, "DetectedIssue", (DetectedIssue)resource, -1); 13061 else if (resource instanceof Device) 13062 composeDevice(parent, null, "Device", (Device)resource, -1); 13063 else if (resource instanceof DeviceComponent) 13064 composeDeviceComponent(parent, null, "DeviceComponent", (DeviceComponent)resource, -1); 13065 else if (resource instanceof DeviceMetric) 13066 composeDeviceMetric(parent, null, "DeviceMetric", (DeviceMetric)resource, -1); 13067 else if (resource instanceof DeviceRequest) 13068 composeDeviceRequest(parent, null, "DeviceRequest", (DeviceRequest)resource, -1); 13069 else if (resource instanceof DeviceUseStatement) 13070 composeDeviceUseStatement(parent, null, "DeviceUseStatement", (DeviceUseStatement)resource, -1); 13071 else if (resource instanceof DiagnosticReport) 13072 composeDiagnosticReport(parent, null, "DiagnosticReport", (DiagnosticReport)resource, -1); 13073 else if (resource instanceof DocumentManifest) 13074 composeDocumentManifest(parent, null, "DocumentManifest", (DocumentManifest)resource, -1); 13075 else if (resource instanceof DocumentReference) 13076 composeDocumentReference(parent, null, "DocumentReference", (DocumentReference)resource, -1); 13077 else if (resource instanceof EligibilityRequest) 13078 composeEligibilityRequest(parent, null, "EligibilityRequest", (EligibilityRequest)resource, -1); 13079 else if (resource instanceof EligibilityResponse) 13080 composeEligibilityResponse(parent, null, "EligibilityResponse", (EligibilityResponse)resource, -1); 13081 else if (resource instanceof Encounter) 13082 composeEncounter(parent, null, "Encounter", (Encounter)resource, -1); 13083 else if (resource instanceof Endpoint) 13084 composeEndpoint(parent, null, "Endpoint", (Endpoint)resource, -1); 13085 else if (resource instanceof EnrollmentRequest) 13086 composeEnrollmentRequest(parent, null, "EnrollmentRequest", (EnrollmentRequest)resource, -1); 13087 else if (resource instanceof EnrollmentResponse) 13088 composeEnrollmentResponse(parent, null, "EnrollmentResponse", (EnrollmentResponse)resource, -1); 13089 else if (resource instanceof EpisodeOfCare) 13090 composeEpisodeOfCare(parent, null, "EpisodeOfCare", (EpisodeOfCare)resource, -1); 13091 else if (resource instanceof ExpansionProfile) 13092 composeExpansionProfile(parent, null, "ExpansionProfile", (ExpansionProfile)resource, -1); 13093 else if (resource instanceof ExplanationOfBenefit) 13094 composeExplanationOfBenefit(parent, null, "ExplanationOfBenefit", (ExplanationOfBenefit)resource, -1); 13095 else if (resource instanceof FamilyMemberHistory) 13096 composeFamilyMemberHistory(parent, null, "FamilyMemberHistory", (FamilyMemberHistory)resource, -1); 13097 else if (resource instanceof Flag) 13098 composeFlag(parent, null, "Flag", (Flag)resource, -1); 13099 else if (resource instanceof Goal) 13100 composeGoal(parent, null, "Goal", (Goal)resource, -1); 13101 else if (resource instanceof GraphDefinition) 13102 composeGraphDefinition(parent, null, "GraphDefinition", (GraphDefinition)resource, -1); 13103 else if (resource instanceof Group) 13104 composeGroup(parent, null, "Group", (Group)resource, -1); 13105 else if (resource instanceof GuidanceResponse) 13106 composeGuidanceResponse(parent, null, "GuidanceResponse", (GuidanceResponse)resource, -1); 13107 else if (resource instanceof HealthcareService) 13108 composeHealthcareService(parent, null, "HealthcareService", (HealthcareService)resource, -1); 13109 else if (resource instanceof ImagingManifest) 13110 composeImagingManifest(parent, null, "ImagingManifest", (ImagingManifest)resource, -1); 13111 else if (resource instanceof ImagingStudy) 13112 composeImagingStudy(parent, null, "ImagingStudy", (ImagingStudy)resource, -1); 13113 else if (resource instanceof Immunization) 13114 composeImmunization(parent, null, "Immunization", (Immunization)resource, -1); 13115 else if (resource instanceof ImmunizationRecommendation) 13116 composeImmunizationRecommendation(parent, null, "ImmunizationRecommendation", (ImmunizationRecommendation)resource, -1); 13117 else if (resource instanceof ImplementationGuide) 13118 composeImplementationGuide(parent, null, "ImplementationGuide", (ImplementationGuide)resource, -1); 13119 else if (resource instanceof Library) 13120 composeLibrary(parent, null, "Library", (Library)resource, -1); 13121 else if (resource instanceof Linkage) 13122 composeLinkage(parent, null, "Linkage", (Linkage)resource, -1); 13123 else if (resource instanceof ListResource) 13124 composeListResource(parent, null, "ListResource", (ListResource)resource, -1); 13125 else if (resource instanceof Location) 13126 composeLocation(parent, null, "Location", (Location)resource, -1); 13127 else if (resource instanceof Measure) 13128 composeMeasure(parent, null, "Measure", (Measure)resource, -1); 13129 else if (resource instanceof MeasureReport) 13130 composeMeasureReport(parent, null, "MeasureReport", (MeasureReport)resource, -1); 13131 else if (resource instanceof Media) 13132 composeMedia(parent, null, "Media", (Media)resource, -1); 13133 else if (resource instanceof Medication) 13134 composeMedication(parent, null, "Medication", (Medication)resource, -1); 13135 else if (resource instanceof MedicationAdministration) 13136 composeMedicationAdministration(parent, null, "MedicationAdministration", (MedicationAdministration)resource, -1); 13137 else if (resource instanceof MedicationDispense) 13138 composeMedicationDispense(parent, null, "MedicationDispense", (MedicationDispense)resource, -1); 13139 else if (resource instanceof MedicationRequest) 13140 composeMedicationRequest(parent, null, "MedicationRequest", (MedicationRequest)resource, -1); 13141 else if (resource instanceof MedicationStatement) 13142 composeMedicationStatement(parent, null, "MedicationStatement", (MedicationStatement)resource, -1); 13143 else if (resource instanceof MessageDefinition) 13144 composeMessageDefinition(parent, null, "MessageDefinition", (MessageDefinition)resource, -1); 13145 else if (resource instanceof MessageHeader) 13146 composeMessageHeader(parent, null, "MessageHeader", (MessageHeader)resource, -1); 13147 else if (resource instanceof NamingSystem) 13148 composeNamingSystem(parent, null, "NamingSystem", (NamingSystem)resource, -1); 13149 else if (resource instanceof NutritionOrder) 13150 composeNutritionOrder(parent, null, "NutritionOrder", (NutritionOrder)resource, -1); 13151 else if (resource instanceof Observation) 13152 composeObservation(parent, null, "Observation", (Observation)resource, -1); 13153 else if (resource instanceof OperationDefinition) 13154 composeOperationDefinition(parent, null, "OperationDefinition", (OperationDefinition)resource, -1); 13155 else if (resource instanceof OperationOutcome) 13156 composeOperationOutcome(parent, null, "OperationOutcome", (OperationOutcome)resource, -1); 13157 else if (resource instanceof Organization) 13158 composeOrganization(parent, null, "Organization", (Organization)resource, -1); 13159 else if (resource instanceof Patient) 13160 composePatient(parent, null, "Patient", (Patient)resource, -1); 13161 else if (resource instanceof PaymentNotice) 13162 composePaymentNotice(parent, null, "PaymentNotice", (PaymentNotice)resource, -1); 13163 else if (resource instanceof PaymentReconciliation) 13164 composePaymentReconciliation(parent, null, "PaymentReconciliation", (PaymentReconciliation)resource, -1); 13165 else if (resource instanceof Person) 13166 composePerson(parent, null, "Person", (Person)resource, -1); 13167 else if (resource instanceof PlanDefinition) 13168 composePlanDefinition(parent, null, "PlanDefinition", (PlanDefinition)resource, -1); 13169 else if (resource instanceof Practitioner) 13170 composePractitioner(parent, null, "Practitioner", (Practitioner)resource, -1); 13171 else if (resource instanceof PractitionerRole) 13172 composePractitionerRole(parent, null, "PractitionerRole", (PractitionerRole)resource, -1); 13173 else if (resource instanceof Procedure) 13174 composeProcedure(parent, null, "Procedure", (Procedure)resource, -1); 13175 else if (resource instanceof ProcedureRequest) 13176 composeProcedureRequest(parent, null, "ProcedureRequest", (ProcedureRequest)resource, -1); 13177 else if (resource instanceof ProcessRequest) 13178 composeProcessRequest(parent, null, "ProcessRequest", (ProcessRequest)resource, -1); 13179 else if (resource instanceof ProcessResponse) 13180 composeProcessResponse(parent, null, "ProcessResponse", (ProcessResponse)resource, -1); 13181 else if (resource instanceof Provenance) 13182 composeProvenance(parent, null, "Provenance", (Provenance)resource, -1); 13183 else if (resource instanceof Questionnaire) 13184 composeQuestionnaire(parent, null, "Questionnaire", (Questionnaire)resource, -1); 13185 else if (resource instanceof QuestionnaireResponse) 13186 composeQuestionnaireResponse(parent, null, "QuestionnaireResponse", (QuestionnaireResponse)resource, -1); 13187 else if (resource instanceof ReferralRequest) 13188 composeReferralRequest(parent, null, "ReferralRequest", (ReferralRequest)resource, -1); 13189 else if (resource instanceof RelatedPerson) 13190 composeRelatedPerson(parent, null, "RelatedPerson", (RelatedPerson)resource, -1); 13191 else if (resource instanceof RequestGroup) 13192 composeRequestGroup(parent, null, "RequestGroup", (RequestGroup)resource, -1); 13193 else if (resource instanceof ResearchStudy) 13194 composeResearchStudy(parent, null, "ResearchStudy", (ResearchStudy)resource, -1); 13195 else if (resource instanceof ResearchSubject) 13196 composeResearchSubject(parent, null, "ResearchSubject", (ResearchSubject)resource, -1); 13197 else if (resource instanceof RiskAssessment) 13198 composeRiskAssessment(parent, null, "RiskAssessment", (RiskAssessment)resource, -1); 13199 else if (resource instanceof Schedule) 13200 composeSchedule(parent, null, "Schedule", (Schedule)resource, -1); 13201 else if (resource instanceof SearchParameter) 13202 composeSearchParameter(parent, null, "SearchParameter", (SearchParameter)resource, -1); 13203 else if (resource instanceof Sequence) 13204 composeSequence(parent, null, "Sequence", (Sequence)resource, -1); 13205 else if (resource instanceof ServiceDefinition) 13206 composeServiceDefinition(parent, null, "ServiceDefinition", (ServiceDefinition)resource, -1); 13207 else if (resource instanceof Slot) 13208 composeSlot(parent, null, "Slot", (Slot)resource, -1); 13209 else if (resource instanceof Specimen) 13210 composeSpecimen(parent, null, "Specimen", (Specimen)resource, -1); 13211 else if (resource instanceof StructureDefinition) 13212 composeStructureDefinition(parent, null, "StructureDefinition", (StructureDefinition)resource, -1); 13213 else if (resource instanceof StructureMap) 13214 composeStructureMap(parent, null, "StructureMap", (StructureMap)resource, -1); 13215 else if (resource instanceof Subscription) 13216 composeSubscription(parent, null, "Subscription", (Subscription)resource, -1); 13217 else if (resource instanceof Substance) 13218 composeSubstance(parent, null, "Substance", (Substance)resource, -1); 13219 else if (resource instanceof SupplyDelivery) 13220 composeSupplyDelivery(parent, null, "SupplyDelivery", (SupplyDelivery)resource, -1); 13221 else if (resource instanceof SupplyRequest) 13222 composeSupplyRequest(parent, null, "SupplyRequest", (SupplyRequest)resource, -1); 13223 else if (resource instanceof Task) 13224 composeTask(parent, null, "Task", (Task)resource, -1); 13225 else if (resource instanceof TestReport) 13226 composeTestReport(parent, null, "TestReport", (TestReport)resource, -1); 13227 else if (resource instanceof TestScript) 13228 composeTestScript(parent, null, "TestScript", (TestScript)resource, -1); 13229 else if (resource instanceof ValueSet) 13230 composeValueSet(parent, null, "ValueSet", (ValueSet)resource, -1); 13231 else if (resource instanceof VisionPrescription) 13232 composeVisionPrescription(parent, null, "VisionPrescription", (VisionPrescription)resource, -1); 13233 else 13234 throw new Error("Unhandled resource type "+resource.getClass().getName()); 13235 } 13236 13237 protected void composeType(Complex parent, String parentType, String name, Type value, int index) { 13238 if (value == null) 13239 return; 13240 else if (value instanceof DateType) 13241 composeDate(parent, parentType, name, (DateType)value, index); 13242 else if (value instanceof DateTimeType) 13243 composeDateTime(parent, parentType, name, (DateTimeType)value, index); 13244 else if (value instanceof CodeType) 13245 composeCode(parent, parentType, name, (CodeType)value, index); 13246 else if (value instanceof StringType) 13247 composeString(parent, parentType, name, (StringType)value, index); 13248 else if (value instanceof IntegerType) 13249 composeInteger(parent, parentType, name, (IntegerType)value, index); 13250 else if (value instanceof OidType) 13251 composeOid(parent, parentType, name, (OidType)value, index); 13252 else if (value instanceof UriType) 13253 composeUri(parent, parentType, name, (UriType)value, index); 13254 else if (value instanceof UuidType) 13255 composeUuid(parent, parentType, name, (UuidType)value, index); 13256 else if (value instanceof InstantType) 13257 composeInstant(parent, parentType, name, (InstantType)value, index); 13258 else if (value instanceof BooleanType) 13259 composeBoolean(parent, parentType, name, (BooleanType)value, index); 13260 else if (value instanceof Base64BinaryType) 13261 composeBase64Binary(parent, parentType, name, (Base64BinaryType)value, index); 13262 else if (value instanceof UnsignedIntType) 13263 composeUnsignedInt(parent, parentType, name, (UnsignedIntType)value, index); 13264 else if (value instanceof MarkdownType) 13265 composeMarkdown(parent, parentType, name, (MarkdownType)value, index); 13266 else if (value instanceof TimeType) 13267 composeTime(parent, parentType, name, (TimeType)value, index); 13268 else if (value instanceof IdType) 13269 composeId(parent, parentType, name, (IdType)value, index); 13270 else if (value instanceof PositiveIntType) 13271 composePositiveInt(parent, parentType, name, (PositiveIntType)value, index); 13272 else if (value instanceof DecimalType) 13273 composeDecimal(parent, parentType, name, (DecimalType)value, index); 13274 else if (value instanceof Extension) 13275 composeExtension(parent, parentType, name, (Extension)value, index); 13276 else if (value instanceof Narrative) 13277 composeNarrative(parent, parentType, name, (Narrative)value, index); 13278 else if (value instanceof Reference) 13279 composeReference(parent, parentType, name, (Reference)value, index); 13280 else if (value instanceof Quantity) 13281 composeQuantity(parent, parentType, name, (Quantity)value, index); 13282 else if (value instanceof Period) 13283 composePeriod(parent, parentType, name, (Period)value, index); 13284 else if (value instanceof Attachment) 13285 composeAttachment(parent, parentType, name, (Attachment)value, index); 13286 else if (value instanceof Duration) 13287 composeDuration(parent, parentType, name, (Duration)value, index); 13288 else if (value instanceof Count) 13289 composeCount(parent, parentType, name, (Count)value, index); 13290 else if (value instanceof Range) 13291 composeRange(parent, parentType, name, (Range)value, index); 13292 else if (value instanceof Annotation) 13293 composeAnnotation(parent, parentType, name, (Annotation)value, index); 13294 else if (value instanceof Money) 13295 composeMoney(parent, parentType, name, (Money)value, index); 13296 else if (value instanceof Identifier) 13297 composeIdentifier(parent, parentType, name, (Identifier)value, index); 13298 else if (value instanceof Coding) 13299 composeCoding(parent, parentType, name, (Coding)value, index); 13300 else if (value instanceof Signature) 13301 composeSignature(parent, parentType, name, (Signature)value, index); 13302 else if (value instanceof SampledData) 13303 composeSampledData(parent, parentType, name, (SampledData)value, index); 13304 else if (value instanceof Ratio) 13305 composeRatio(parent, parentType, name, (Ratio)value, index); 13306 else if (value instanceof Distance) 13307 composeDistance(parent, parentType, name, (Distance)value, index); 13308 else if (value instanceof Age) 13309 composeAge(parent, parentType, name, (Age)value, index); 13310 else if (value instanceof CodeableConcept) 13311 composeCodeableConcept(parent, parentType, name, (CodeableConcept)value, index); 13312 else if (value instanceof Meta) 13313 composeMeta(parent, parentType, name, (Meta)value, index); 13314 else if (value instanceof Address) 13315 composeAddress(parent, parentType, name, (Address)value, index); 13316 else if (value instanceof TriggerDefinition) 13317 composeTriggerDefinition(parent, parentType, name, (TriggerDefinition)value, index); 13318 else if (value instanceof Contributor) 13319 composeContributor(parent, parentType, name, (Contributor)value, index); 13320 else if (value instanceof DataRequirement) 13321 composeDataRequirement(parent, parentType, name, (DataRequirement)value, index); 13322 else if (value instanceof Dosage) 13323 composeDosage(parent, parentType, name, (Dosage)value, index); 13324 else if (value instanceof RelatedArtifact) 13325 composeRelatedArtifact(parent, parentType, name, (RelatedArtifact)value, index); 13326 else if (value instanceof ContactDetail) 13327 composeContactDetail(parent, parentType, name, (ContactDetail)value, index); 13328 else if (value instanceof HumanName) 13329 composeHumanName(parent, parentType, name, (HumanName)value, index); 13330 else if (value instanceof ContactPoint) 13331 composeContactPoint(parent, parentType, name, (ContactPoint)value, index); 13332 else if (value instanceof UsageContext) 13333 composeUsageContext(parent, parentType, name, (UsageContext)value, index); 13334 else if (value instanceof Timing) 13335 composeTiming(parent, parentType, name, (Timing)value, index); 13336 else if (value instanceof ElementDefinition) 13337 composeElementDefinition(parent, parentType, name, (ElementDefinition)value, index); 13338 else if (value instanceof ParameterDefinition) 13339 composeParameterDefinition(parent, parentType, name, (ParameterDefinition)value, index); 13340 else 13341 throw new Error("Unhandled type"); 13342 } 13343 13344} 13345