001package org.hl7.fhir.dstu3.formats; 002 003/* 004 Copyright (c) 2011+, HL7, Inc. 005 All rights reserved. 006 007 Redistribution and use in source and binary forms, with or without modification, 008 are permitted provided that the following conditions are met: 009 010 * Redistributions of source code must retain the above copyright notice, this 011 list of conditions and the following disclaimer. 012 * Redistributions in binary form must reproduce the above copyright notice, 013 this list of conditions and the following disclaimer in the documentation 014 and/or other materials provided with the distribution. 015 * Neither the name of HL7 nor the names of its contributors may be used to 016 endorse or promote products derived from this software without specific 017 prior written permission. 018 019 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 020 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 021 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 022 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 023 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 024 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 025 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 026 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 027 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 028 POSSIBILITY OF SUCH DAMAGE. 029 030*/ 031 032// Generated on Mon, Apr 17, 2017 08:38+1000 for FHIR v3.0.x 033import org.hl7.fhir.dstu3.model.*; 034import org.hl7.fhir.utilities.Utilities; 035import org.hl7.fhir.utilities.turtle.Turtle; 036import org.hl7.fhir.utilities.turtle.Turtle.Complex; 037 038public class RdfParser extends RdfParserBase { 039 040 public RdfParser() { 041 super(); 042 } 043 044 public RdfParser(boolean allowUnknownContent) { 045 super(); 046 setAllowUnknownContent(allowUnknownContent); 047 } 048 049 050 protected void composeElement(Complex t, String parentType, String name, Element element, int index) { 051 if (element == null) 052 return; 053 if (index > -1) 054 t.predicate("fhir:index", Integer.toString(index)); 055 if (element.hasIdElement()) 056 composeString(t, "Element", "id", element.getIdElement(), -1); 057 for (int i = 0; i < element.getExtension().size(); i++) 058 composeExtension(t, "Element", "extension", element.getExtension().get(i), i); 059 } 060 061 protected void composeBackboneElement(Complex t, String tType, String name, BackboneElement element, int index) { 062 composeElement(t, tType, name, element, index); 063 for (int i = 0; i < element.getModifierExtension().size(); i++) 064 composeExtension(t, "Element", "modifierExtension", element.getModifierExtension().get(i), i); 065 } 066 067 private void composeEnum(Complex parent, String parentType, String name, Enumeration<? extends Enum> value, int index) { 068 if (value == null) 069 return; 070 Complex t = parent.predicate("fhir:"+parentType+"."+name); 071 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 072 composeElement(t, parentType, name, value, index); 073 decorateCode(t, value); 074 } 075 076 077 protected void composeDate(Complex parent, String parentType, String name, DateType value, int index) { 078 if (value == null) 079 return; 080 Complex t = parent.predicate("fhir:"+parentType+"."+name); 081 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 082 composeElement(t, parentType, name, value, index); 083 } 084 085 protected void composeDateTime(Complex parent, String parentType, String name, DateTimeType value, int index) { 086 if (value == null) 087 return; 088 Complex t = parent.predicate("fhir:"+parentType+"."+name); 089 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 090 composeElement(t, parentType, name, value, index); 091 } 092 093 protected void composeCode(Complex parent, String parentType, String name, CodeType value, int index) { 094 if (value == null) 095 return; 096 Complex t = parent.predicate("fhir:"+parentType+"."+name); 097 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 098 composeElement(t, parentType, name, value, index); 099 decorateCode(t, value); 100 } 101 102 protected void composeString(Complex parent, String parentType, String name, StringType value, int index) { 103 if (value == null) 104 return; 105 Complex t = parent.predicate("fhir:"+parentType+"."+name); 106 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 107 composeElement(t, parentType, name, value, index); 108 } 109 110 protected void composeInteger(Complex parent, String parentType, String name, IntegerType value, int index) { 111 if (value == null) 112 return; 113 Complex t = parent.predicate("fhir:"+parentType+"."+name); 114 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 115 composeElement(t, parentType, name, value, index); 116 } 117 118 protected void composeOid(Complex parent, String parentType, String name, OidType value, int index) { 119 if (value == null) 120 return; 121 Complex t = parent.predicate("fhir:"+parentType+"."+name); 122 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 123 composeElement(t, parentType, name, value, index); 124 } 125 126 protected void composeUri(Complex parent, String parentType, String name, UriType value, int index) { 127 if (value == null) 128 return; 129 Complex t = parent.predicate("fhir:"+parentType+"."+name); 130 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 131 composeElement(t, parentType, name, value, index); 132 } 133 134 protected void composeUuid(Complex parent, String parentType, String name, UuidType value, int index) { 135 if (value == null) 136 return; 137 Complex t = parent.predicate("fhir:"+parentType+"."+name); 138 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 139 composeElement(t, parentType, name, value, index); 140 } 141 142 protected void composeInstant(Complex parent, String parentType, String name, InstantType value, int index) { 143 if (value == null) 144 return; 145 Complex t = parent.predicate("fhir:"+parentType+"."+name); 146 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 147 composeElement(t, parentType, name, value, index); 148 } 149 150 protected void composeBoolean(Complex parent, String parentType, String name, BooleanType value, int index) { 151 if (value == null) 152 return; 153 Complex t = parent.predicate("fhir:"+parentType+"."+name); 154 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 155 composeElement(t, parentType, name, value, index); 156 } 157 158 protected void composeBase64Binary(Complex parent, String parentType, String name, Base64BinaryType value, int index) { 159 if (value == null) 160 return; 161 Complex t = parent.predicate("fhir:"+parentType+"."+name); 162 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 163 composeElement(t, parentType, name, value, index); 164 } 165 166 protected void composeUnsignedInt(Complex parent, String parentType, String name, UnsignedIntType value, int index) { 167 if (value == null) 168 return; 169 Complex t = parent.predicate("fhir:"+parentType+"."+name); 170 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 171 composeElement(t, parentType, name, value, index); 172 } 173 174 protected void composeMarkdown(Complex parent, String parentType, String name, MarkdownType value, int index) { 175 if (value == null) 176 return; 177 Complex t = parent.predicate("fhir:"+parentType+"."+name); 178 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 179 composeElement(t, parentType, name, value, index); 180 } 181 182 protected void composeTime(Complex parent, String parentType, String name, TimeType value, int index) { 183 if (value == null) 184 return; 185 Complex t = parent.predicate("fhir:"+parentType+"."+name); 186 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 187 composeElement(t, parentType, name, value, index); 188 } 189 190 protected void composeId(Complex parent, String parentType, String name, IdType value, int index) { 191 if (value == null) 192 return; 193 Complex t = parent.predicate("fhir:"+parentType+"."+name); 194 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 195 composeElement(t, parentType, name, value, index); 196 } 197 198 protected void composePositiveInt(Complex parent, String parentType, String name, PositiveIntType value, int index) { 199 if (value == null) 200 return; 201 Complex t = parent.predicate("fhir:"+parentType+"."+name); 202 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 203 composeElement(t, parentType, name, value, index); 204 } 205 206 protected void composeDecimal(Complex parent, String parentType, String name, DecimalType value, int index) { 207 if (value == null) 208 return; 209 Complex t = parent.predicate("fhir:"+parentType+"."+name); 210 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 211 composeElement(t, parentType, name, value, index); 212 } 213 214 protected void composeExtension(Complex parent, String parentType, String name, Extension element, int index) { 215 if (element == null) 216 return; 217 Complex t; 218 if (Utilities.noString(parentType)) 219 t = parent; 220 else { 221 t = parent.predicate("fhir:"+parentType+'.'+name); 222 } 223 composeElement(t, "Extension", name, element, index); 224 if (element.hasUrlElement()) 225 composeUri(t, "Extension", "url", element.getUrlElement(), -1); 226 if (element.hasValue()) 227 composeType(t, "Extension", "value", element.getValue(), -1); 228 } 229 230 protected void composeNarrative(Complex parent, String parentType, String name, Narrative element, int index) { 231 if (element == null) 232 return; 233 Complex t; 234 if (Utilities.noString(parentType)) 235 t = parent; 236 else { 237 t = parent.predicate("fhir:"+parentType+'.'+name); 238 } 239 composeElement(t, "Narrative", name, element, index); 240 if (element.hasStatusElement()) 241 composeEnum(t, "Narrative", "status", element.getStatusElement(), -1); 242 if (element.hasDiv()) 243 composeXhtml(t, "Narrative", "div", element.getDiv(), -1); 244 } 245 246 protected void composeReference(Complex parent, String parentType, String name, Reference element, int index) { 247 if (element == null) 248 return; 249 Complex t; 250 if (Utilities.noString(parentType)) 251 t = parent; 252 else { 253 t = parent.predicate("fhir:"+parentType+'.'+name); 254 } 255 composeElement(t, "Reference", name, element, index); 256 if (element.hasReferenceElement()) 257 composeString(t, "Reference", "reference", element.getReferenceElement_(), -1); 258 if (element.hasIdentifier()) 259 composeIdentifier(t, "Reference", "identifier", element.getIdentifier(), -1); 260 if (element.hasDisplayElement()) 261 composeString(t, "Reference", "display", element.getDisplayElement(), -1); 262 } 263 264 protected void composeQuantity(Complex parent, String parentType, String name, Quantity element, int index) { 265 if (element == null) 266 return; 267 Complex t; 268 if (Utilities.noString(parentType)) 269 t = parent; 270 else { 271 t = parent.predicate("fhir:"+parentType+'.'+name); 272 } 273 composeElement(t, "Quantity", name, element, index); 274 if (element.hasValueElement()) 275 composeDecimal(t, "Quantity", "value", element.getValueElement(), -1); 276 if (element.hasComparatorElement()) 277 composeEnum(t, "Quantity", "comparator", element.getComparatorElement(), -1); 278 if (element.hasUnitElement()) 279 composeString(t, "Quantity", "unit", element.getUnitElement(), -1); 280 if (element.hasSystemElement()) 281 composeUri(t, "Quantity", "system", element.getSystemElement(), -1); 282 if (element.hasCodeElement()) 283 composeCode(t, "Quantity", "code", element.getCodeElement(), -1); 284 } 285 286 protected void composePeriod(Complex parent, String parentType, String name, Period element, int index) { 287 if (element == null) 288 return; 289 Complex t; 290 if (Utilities.noString(parentType)) 291 t = parent; 292 else { 293 t = parent.predicate("fhir:"+parentType+'.'+name); 294 } 295 composeElement(t, "Period", name, element, index); 296 if (element.hasStartElement()) 297 composeDateTime(t, "Period", "start", element.getStartElement(), -1); 298 if (element.hasEndElement()) 299 composeDateTime(t, "Period", "end", element.getEndElement(), -1); 300 } 301 302 protected void composeAttachment(Complex parent, String parentType, String name, Attachment element, int index) { 303 if (element == null) 304 return; 305 Complex t; 306 if (Utilities.noString(parentType)) 307 t = parent; 308 else { 309 t = parent.predicate("fhir:"+parentType+'.'+name); 310 } 311 composeElement(t, "Attachment", name, element, index); 312 if (element.hasContentTypeElement()) 313 composeCode(t, "Attachment", "contentType", element.getContentTypeElement(), -1); 314 if (element.hasLanguageElement()) 315 composeCode(t, "Attachment", "language", element.getLanguageElement(), -1); 316 if (element.hasDataElement()) 317 composeBase64Binary(t, "Attachment", "data", element.getDataElement(), -1); 318 if (element.hasUrlElement()) 319 composeUri(t, "Attachment", "url", element.getUrlElement(), -1); 320 if (element.hasSizeElement()) 321 composeUnsignedInt(t, "Attachment", "size", element.getSizeElement(), -1); 322 if (element.hasHashElement()) 323 composeBase64Binary(t, "Attachment", "hash", element.getHashElement(), -1); 324 if (element.hasTitleElement()) 325 composeString(t, "Attachment", "title", element.getTitleElement(), -1); 326 if (element.hasCreationElement()) 327 composeDateTime(t, "Attachment", "creation", element.getCreationElement(), -1); 328 } 329 330 protected void composeDuration(Complex parent, String parentType, String name, Duration element, int index) { 331 if (element == null) 332 return; 333 Complex t; 334 if (Utilities.noString(parentType)) 335 t = parent; 336 else { 337 t = parent.predicate("fhir:"+parentType+'.'+name); 338 } 339 composeElement(t, "Duration", name, element, index); 340 } 341 342 protected void composeCount(Complex parent, String parentType, String name, Count element, int index) { 343 if (element == null) 344 return; 345 Complex t; 346 if (Utilities.noString(parentType)) 347 t = parent; 348 else { 349 t = parent.predicate("fhir:"+parentType+'.'+name); 350 } 351 composeElement(t, "Count", name, element, index); 352 } 353 354 protected void composeRange(Complex parent, String parentType, String name, Range element, int index) { 355 if (element == null) 356 return; 357 Complex t; 358 if (Utilities.noString(parentType)) 359 t = parent; 360 else { 361 t = parent.predicate("fhir:"+parentType+'.'+name); 362 } 363 composeElement(t, "Range", name, element, index); 364 if (element.hasLow()) 365 composeQuantity(t, "Range", "low", element.getLow(), -1); 366 if (element.hasHigh()) 367 composeQuantity(t, "Range", "high", element.getHigh(), -1); 368 } 369 370 protected void composeAnnotation(Complex parent, String parentType, String name, Annotation element, int index) { 371 if (element == null) 372 return; 373 Complex t; 374 if (Utilities.noString(parentType)) 375 t = parent; 376 else { 377 t = parent.predicate("fhir:"+parentType+'.'+name); 378 } 379 composeElement(t, "Annotation", name, element, index); 380 if (element.hasAuthor()) 381 composeType(t, "Annotation", "author", element.getAuthor(), -1); 382 if (element.hasTimeElement()) 383 composeDateTime(t, "Annotation", "time", element.getTimeElement(), -1); 384 if (element.hasTextElement()) 385 composeString(t, "Annotation", "text", element.getTextElement(), -1); 386 } 387 388 protected void composeMoney(Complex parent, String parentType, String name, Money element, int index) { 389 if (element == null) 390 return; 391 Complex t; 392 if (Utilities.noString(parentType)) 393 t = parent; 394 else { 395 t = parent.predicate("fhir:"+parentType+'.'+name); 396 } 397 composeElement(t, "Money", name, element, index); 398 } 399 400 protected void composeIdentifier(Complex parent, String parentType, String name, Identifier element, int index) { 401 if (element == null) 402 return; 403 Complex t; 404 if (Utilities.noString(parentType)) 405 t = parent; 406 else { 407 t = parent.predicate("fhir:"+parentType+'.'+name); 408 } 409 composeElement(t, "Identifier", name, element, index); 410 if (element.hasUseElement()) 411 composeEnum(t, "Identifier", "use", element.getUseElement(), -1); 412 if (element.hasType()) 413 composeCodeableConcept(t, "Identifier", "type", element.getType(), -1); 414 if (element.hasSystemElement()) 415 composeUri(t, "Identifier", "system", element.getSystemElement(), -1); 416 if (element.hasValueElement()) 417 composeString(t, "Identifier", "value", element.getValueElement(), -1); 418 if (element.hasPeriod()) 419 composePeriod(t, "Identifier", "period", element.getPeriod(), -1); 420 if (element.hasAssigner()) 421 composeReference(t, "Identifier", "assigner", element.getAssigner(), -1); 422 } 423 424 protected void composeCoding(Complex parent, String parentType, String name, Coding element, int index) { 425 if (element == null) 426 return; 427 Complex t; 428 if (Utilities.noString(parentType)) 429 t = parent; 430 else { 431 t = parent.predicate("fhir:"+parentType+'.'+name); 432 } 433 composeElement(t, "Coding", name, element, index); 434 decorateCoding(t, element); 435 if (element.hasSystemElement()) 436 composeUri(t, "Coding", "system", element.getSystemElement(), -1); 437 if (element.hasVersionElement()) 438 composeString(t, "Coding", "version", element.getVersionElement(), -1); 439 if (element.hasCodeElement()) 440 composeCode(t, "Coding", "code", element.getCodeElement(), -1); 441 if (element.hasDisplayElement()) 442 composeString(t, "Coding", "display", element.getDisplayElement(), -1); 443 if (element.hasUserSelectedElement()) 444 composeBoolean(t, "Coding", "userSelected", element.getUserSelectedElement(), -1); 445 } 446 447 protected void composeSignature(Complex parent, String parentType, String name, Signature element, int index) { 448 if (element == null) 449 return; 450 Complex t; 451 if (Utilities.noString(parentType)) 452 t = parent; 453 else { 454 t = parent.predicate("fhir:"+parentType+'.'+name); 455 } 456 composeElement(t, "Signature", name, element, index); 457 for (int i = 0; i < element.getType().size(); i++) 458 composeCoding(t, "Signature", "type", element.getType().get(i), i); 459 if (element.hasWhenElement()) 460 composeInstant(t, "Signature", "when", element.getWhenElement(), -1); 461 if (element.hasWho()) 462 composeType(t, "Signature", "who", element.getWho(), -1); 463 if (element.hasOnBehalfOf()) 464 composeType(t, "Signature", "onBehalfOf", element.getOnBehalfOf(), -1); 465 if (element.hasContentTypeElement()) 466 composeCode(t, "Signature", "contentType", element.getContentTypeElement(), -1); 467 if (element.hasBlobElement()) 468 composeBase64Binary(t, "Signature", "blob", element.getBlobElement(), -1); 469 } 470 471 protected void composeSampledData(Complex parent, String parentType, String name, SampledData element, int index) { 472 if (element == null) 473 return; 474 Complex t; 475 if (Utilities.noString(parentType)) 476 t = parent; 477 else { 478 t = parent.predicate("fhir:"+parentType+'.'+name); 479 } 480 composeElement(t, "SampledData", name, element, index); 481 if (element.hasOrigin()) 482 composeQuantity(t, "SampledData", "origin", element.getOrigin(), -1); 483 if (element.hasPeriodElement()) 484 composeDecimal(t, "SampledData", "period", element.getPeriodElement(), -1); 485 if (element.hasFactorElement()) 486 composeDecimal(t, "SampledData", "factor", element.getFactorElement(), -1); 487 if (element.hasLowerLimitElement()) 488 composeDecimal(t, "SampledData", "lowerLimit", element.getLowerLimitElement(), -1); 489 if (element.hasUpperLimitElement()) 490 composeDecimal(t, "SampledData", "upperLimit", element.getUpperLimitElement(), -1); 491 if (element.hasDimensionsElement()) 492 composePositiveInt(t, "SampledData", "dimensions", element.getDimensionsElement(), -1); 493 if (element.hasDataElement()) 494 composeString(t, "SampledData", "data", element.getDataElement(), -1); 495 } 496 497 protected void composeRatio(Complex parent, String parentType, String name, Ratio element, int index) { 498 if (element == null) 499 return; 500 Complex t; 501 if (Utilities.noString(parentType)) 502 t = parent; 503 else { 504 t = parent.predicate("fhir:"+parentType+'.'+name); 505 } 506 composeElement(t, "Ratio", name, element, index); 507 if (element.hasNumerator()) 508 composeQuantity(t, "Ratio", "numerator", element.getNumerator(), -1); 509 if (element.hasDenominator()) 510 composeQuantity(t, "Ratio", "denominator", element.getDenominator(), -1); 511 } 512 513 protected void composeDistance(Complex parent, String parentType, String name, Distance element, int index) { 514 if (element == null) 515 return; 516 Complex t; 517 if (Utilities.noString(parentType)) 518 t = parent; 519 else { 520 t = parent.predicate("fhir:"+parentType+'.'+name); 521 } 522 composeElement(t, "Distance", name, element, index); 523 } 524 525 protected void composeAge(Complex parent, String parentType, String name, Age element, int index) { 526 if (element == null) 527 return; 528 Complex t; 529 if (Utilities.noString(parentType)) 530 t = parent; 531 else { 532 t = parent.predicate("fhir:"+parentType+'.'+name); 533 } 534 composeElement(t, "Age", name, element, index); 535 } 536 537 protected void composeCodeableConcept(Complex parent, String parentType, String name, CodeableConcept element, int index) { 538 if (element == null) 539 return; 540 Complex t; 541 if (Utilities.noString(parentType)) 542 t = parent; 543 else { 544 t = parent.predicate("fhir:"+parentType+'.'+name); 545 } 546 composeElement(t, "CodeableConcept", name, element, index); 547 decorateCodeableConcept(t, element); 548 for (int i = 0; i < element.getCoding().size(); i++) 549 composeCoding(t, "CodeableConcept", "coding", element.getCoding().get(i), i); 550 if (element.hasTextElement()) 551 composeString(t, "CodeableConcept", "text", element.getTextElement(), -1); 552 } 553 554 protected void composeMeta(Complex parent, String parentType, String name, Meta element, int index) { 555 if (element == null) 556 return; 557 Complex t; 558 if (Utilities.noString(parentType)) 559 t = parent; 560 else { 561 t = parent.predicate("fhir:"+parentType+'.'+name); 562 } 563 composeElement(t, "Meta", name, element, index); 564 if (element.hasVersionIdElement()) 565 composeId(t, "Meta", "versionId", element.getVersionIdElement(), -1); 566 if (element.hasLastUpdatedElement()) 567 composeInstant(t, "Meta", "lastUpdated", element.getLastUpdatedElement(), -1); 568 for (int i = 0; i < element.getProfile().size(); i++) 569 composeUri(t, "Meta", "profile", element.getProfile().get(i), i); 570 for (int i = 0; i < element.getSecurity().size(); i++) 571 composeCoding(t, "Meta", "security", element.getSecurity().get(i), i); 572 for (int i = 0; i < element.getTag().size(); i++) 573 composeCoding(t, "Meta", "tag", element.getTag().get(i), i); 574 } 575 576 protected void composeAddress(Complex parent, String parentType, String name, Address element, int index) { 577 if (element == null) 578 return; 579 Complex t; 580 if (Utilities.noString(parentType)) 581 t = parent; 582 else { 583 t = parent.predicate("fhir:"+parentType+'.'+name); 584 } 585 composeElement(t, "Address", name, element, index); 586 if (element.hasUseElement()) 587 composeEnum(t, "Address", "use", element.getUseElement(), -1); 588 if (element.hasTypeElement()) 589 composeEnum(t, "Address", "type", element.getTypeElement(), -1); 590 if (element.hasTextElement()) 591 composeString(t, "Address", "text", element.getTextElement(), -1); 592 for (int i = 0; i < element.getLine().size(); i++) 593 composeString(t, "Address", "line", element.getLine().get(i), i); 594 if (element.hasCityElement()) 595 composeString(t, "Address", "city", element.getCityElement(), -1); 596 if (element.hasDistrictElement()) 597 composeString(t, "Address", "district", element.getDistrictElement(), -1); 598 if (element.hasStateElement()) 599 composeString(t, "Address", "state", element.getStateElement(), -1); 600 if (element.hasPostalCodeElement()) 601 composeString(t, "Address", "postalCode", element.getPostalCodeElement(), -1); 602 if (element.hasCountryElement()) 603 composeString(t, "Address", "country", element.getCountryElement(), -1); 604 if (element.hasPeriod()) 605 composePeriod(t, "Address", "period", element.getPeriod(), -1); 606 } 607 608 protected void composeTriggerDefinition(Complex parent, String parentType, String name, TriggerDefinition element, int index) { 609 if (element == null) 610 return; 611 Complex t; 612 if (Utilities.noString(parentType)) 613 t = parent; 614 else { 615 t = parent.predicate("fhir:"+parentType+'.'+name); 616 } 617 composeElement(t, "TriggerDefinition", name, element, index); 618 if (element.hasTypeElement()) 619 composeEnum(t, "TriggerDefinition", "type", element.getTypeElement(), -1); 620 if (element.hasEventNameElement()) 621 composeString(t, "TriggerDefinition", "eventName", element.getEventNameElement(), -1); 622 if (element.hasEventTiming()) 623 composeType(t, "TriggerDefinition", "eventTiming", element.getEventTiming(), -1); 624 if (element.hasEventData()) 625 composeDataRequirement(t, "TriggerDefinition", "eventData", element.getEventData(), -1); 626 } 627 628 protected void composeContributor(Complex parent, String parentType, String name, Contributor 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, "Contributor", name, element, index); 638 if (element.hasTypeElement()) 639 composeEnum(t, "Contributor", "type", element.getTypeElement(), -1); 640 if (element.hasNameElement()) 641 composeString(t, "Contributor", "name", element.getNameElement(), -1); 642 for (int i = 0; i < element.getContact().size(); i++) 643 composeContactDetail(t, "Contributor", "contact", element.getContact().get(i), i); 644 } 645 646 protected void composeDataRequirement(Complex parent, String parentType, String name, DataRequirement element, int index) { 647 if (element == null) 648 return; 649 Complex t; 650 if (Utilities.noString(parentType)) 651 t = parent; 652 else { 653 t = parent.predicate("fhir:"+parentType+'.'+name); 654 } 655 composeElement(t, "DataRequirement", name, element, index); 656 if (element.hasTypeElement()) 657 composeCode(t, "DataRequirement", "type", element.getTypeElement(), -1); 658 for (int i = 0; i < element.getProfile().size(); i++) 659 composeUri(t, "DataRequirement", "profile", element.getProfile().get(i), i); 660 for (int i = 0; i < element.getMustSupport().size(); i++) 661 composeString(t, "DataRequirement", "mustSupport", element.getMustSupport().get(i), i); 662 for (int i = 0; i < element.getCodeFilter().size(); i++) 663 composeDataRequirementDataRequirementCodeFilterComponent(t, "DataRequirement", "codeFilter", element.getCodeFilter().get(i), i); 664 for (int i = 0; i < element.getDateFilter().size(); i++) 665 composeDataRequirementDataRequirementDateFilterComponent(t, "DataRequirement", "dateFilter", element.getDateFilter().get(i), i); 666 } 667 668 protected void composeDataRequirementDataRequirementCodeFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementCodeFilterComponent element, int index) { 669 if (element == null) 670 return; 671 Complex t; 672 if (Utilities.noString(parentType)) 673 t = parent; 674 else { 675 t = parent.predicate("fhir:"+parentType+'.'+name); 676 } 677 composeElement(t, "codeFilter", name, element, index); 678 if (element.hasPathElement()) 679 composeString(t, "DataRequirement", "path", element.getPathElement(), -1); 680 if (element.hasValueSet()) 681 composeType(t, "DataRequirement", "valueSet", element.getValueSet(), -1); 682 for (int i = 0; i < element.getValueCode().size(); i++) 683 composeCode(t, "DataRequirement", "valueCode", element.getValueCode().get(i), i); 684 for (int i = 0; i < element.getValueCoding().size(); i++) 685 composeCoding(t, "DataRequirement", "valueCoding", element.getValueCoding().get(i), i); 686 for (int i = 0; i < element.getValueCodeableConcept().size(); i++) 687 composeCodeableConcept(t, "DataRequirement", "valueCodeableConcept", element.getValueCodeableConcept().get(i), i); 688 } 689 690 protected void composeDataRequirementDataRequirementDateFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementDateFilterComponent element, int index) { 691 if (element == null) 692 return; 693 Complex t; 694 if (Utilities.noString(parentType)) 695 t = parent; 696 else { 697 t = parent.predicate("fhir:"+parentType+'.'+name); 698 } 699 composeElement(t, "dateFilter", name, element, index); 700 if (element.hasPathElement()) 701 composeString(t, "DataRequirement", "path", element.getPathElement(), -1); 702 if (element.hasValue()) 703 composeType(t, "DataRequirement", "value", element.getValue(), -1); 704 } 705 706 protected void composeDosage(Complex parent, String parentType, String name, Dosage element, int index) { 707 if (element == null) 708 return; 709 Complex t; 710 if (Utilities.noString(parentType)) 711 t = parent; 712 else { 713 t = parent.predicate("fhir:"+parentType+'.'+name); 714 } 715 composeElement(t, "Dosage", name, element, index); 716 if (element.hasSequenceElement()) 717 composeInteger(t, "Dosage", "sequence", element.getSequenceElement(), -1); 718 if (element.hasTextElement()) 719 composeString(t, "Dosage", "text", element.getTextElement(), -1); 720 for (int i = 0; i < element.getAdditionalInstruction().size(); i++) 721 composeCodeableConcept(t, "Dosage", "additionalInstruction", element.getAdditionalInstruction().get(i), i); 722 if (element.hasPatientInstructionElement()) 723 composeString(t, "Dosage", "patientInstruction", element.getPatientInstructionElement(), -1); 724 if (element.hasTiming()) 725 composeTiming(t, "Dosage", "timing", element.getTiming(), -1); 726 if (element.hasAsNeeded()) 727 composeType(t, "Dosage", "asNeeded", element.getAsNeeded(), -1); 728 if (element.hasSite()) 729 composeCodeableConcept(t, "Dosage", "site", element.getSite(), -1); 730 if (element.hasRoute()) 731 composeCodeableConcept(t, "Dosage", "route", element.getRoute(), -1); 732 if (element.hasMethod()) 733 composeCodeableConcept(t, "Dosage", "method", element.getMethod(), -1); 734 if (element.hasDose()) 735 composeType(t, "Dosage", "dose", element.getDose(), -1); 736 if (element.hasMaxDosePerPeriod()) 737 composeRatio(t, "Dosage", "maxDosePerPeriod", element.getMaxDosePerPeriod(), -1); 738 if (element.hasMaxDosePerAdministration()) 739 composeQuantity(t, "Dosage", "maxDosePerAdministration", element.getMaxDosePerAdministration(), -1); 740 if (element.hasMaxDosePerLifetime()) 741 composeQuantity(t, "Dosage", "maxDosePerLifetime", element.getMaxDosePerLifetime(), -1); 742 if (element.hasRate()) 743 composeType(t, "Dosage", "rate", element.getRate(), -1); 744 } 745 746 protected void composeRelatedArtifact(Complex parent, String parentType, String name, RelatedArtifact element, int index) { 747 if (element == null) 748 return; 749 Complex t; 750 if (Utilities.noString(parentType)) 751 t = parent; 752 else { 753 t = parent.predicate("fhir:"+parentType+'.'+name); 754 } 755 composeElement(t, "RelatedArtifact", name, element, index); 756 if (element.hasTypeElement()) 757 composeEnum(t, "RelatedArtifact", "type", element.getTypeElement(), -1); 758 if (element.hasDisplayElement()) 759 composeString(t, "RelatedArtifact", "display", element.getDisplayElement(), -1); 760 if (element.hasCitationElement()) 761 composeString(t, "RelatedArtifact", "citation", element.getCitationElement(), -1); 762 if (element.hasUrlElement()) 763 composeUri(t, "RelatedArtifact", "url", element.getUrlElement(), -1); 764 if (element.hasDocument()) 765 composeAttachment(t, "RelatedArtifact", "document", element.getDocument(), -1); 766 if (element.hasResource()) 767 composeReference(t, "RelatedArtifact", "resource", element.getResource(), -1); 768 } 769 770 protected void composeContactDetail(Complex parent, String parentType, String name, ContactDetail element, int index) { 771 if (element == null) 772 return; 773 Complex t; 774 if (Utilities.noString(parentType)) 775 t = parent; 776 else { 777 t = parent.predicate("fhir:"+parentType+'.'+name); 778 } 779 composeElement(t, "ContactDetail", name, element, index); 780 if (element.hasNameElement()) 781 composeString(t, "ContactDetail", "name", element.getNameElement(), -1); 782 for (int i = 0; i < element.getTelecom().size(); i++) 783 composeContactPoint(t, "ContactDetail", "telecom", element.getTelecom().get(i), i); 784 } 785 786 protected void composeHumanName(Complex parent, String parentType, String name, HumanName element, int index) { 787 if (element == null) 788 return; 789 Complex t; 790 if (Utilities.noString(parentType)) 791 t = parent; 792 else { 793 t = parent.predicate("fhir:"+parentType+'.'+name); 794 } 795 composeElement(t, "HumanName", name, element, index); 796 if (element.hasUseElement()) 797 composeEnum(t, "HumanName", "use", element.getUseElement(), -1); 798 if (element.hasTextElement()) 799 composeString(t, "HumanName", "text", element.getTextElement(), -1); 800 if (element.hasFamilyElement()) 801 composeString(t, "HumanName", "family", element.getFamilyElement(), -1); 802 for (int i = 0; i < element.getGiven().size(); i++) 803 composeString(t, "HumanName", "given", element.getGiven().get(i), i); 804 for (int i = 0; i < element.getPrefix().size(); i++) 805 composeString(t, "HumanName", "prefix", element.getPrefix().get(i), i); 806 for (int i = 0; i < element.getSuffix().size(); i++) 807 composeString(t, "HumanName", "suffix", element.getSuffix().get(i), i); 808 if (element.hasPeriod()) 809 composePeriod(t, "HumanName", "period", element.getPeriod(), -1); 810 } 811 812 protected void composeContactPoint(Complex parent, String parentType, String name, ContactPoint element, int index) { 813 if (element == null) 814 return; 815 Complex t; 816 if (Utilities.noString(parentType)) 817 t = parent; 818 else { 819 t = parent.predicate("fhir:"+parentType+'.'+name); 820 } 821 composeElement(t, "ContactPoint", name, element, index); 822 if (element.hasSystemElement()) 823 composeEnum(t, "ContactPoint", "system", element.getSystemElement(), -1); 824 if (element.hasValueElement()) 825 composeString(t, "ContactPoint", "value", element.getValueElement(), -1); 826 if (element.hasUseElement()) 827 composeEnum(t, "ContactPoint", "use", element.getUseElement(), -1); 828 if (element.hasRankElement()) 829 composePositiveInt(t, "ContactPoint", "rank", element.getRankElement(), -1); 830 if (element.hasPeriod()) 831 composePeriod(t, "ContactPoint", "period", element.getPeriod(), -1); 832 } 833 834 protected void composeUsageContext(Complex parent, String parentType, String name, UsageContext element, int index) { 835 if (element == null) 836 return; 837 Complex t; 838 if (Utilities.noString(parentType)) 839 t = parent; 840 else { 841 t = parent.predicate("fhir:"+parentType+'.'+name); 842 } 843 composeElement(t, "UsageContext", name, element, index); 844 if (element.hasCode()) 845 composeCoding(t, "UsageContext", "code", element.getCode(), -1); 846 if (element.hasValue()) 847 composeType(t, "UsageContext", "value", element.getValue(), -1); 848 } 849 850 protected void composeTiming(Complex parent, String parentType, String name, Timing element, int index) { 851 if (element == null) 852 return; 853 Complex t; 854 if (Utilities.noString(parentType)) 855 t = parent; 856 else { 857 t = parent.predicate("fhir:"+parentType+'.'+name); 858 } 859 composeElement(t, "Timing", name, element, index); 860 for (int i = 0; i < element.getEvent().size(); i++) 861 composeDateTime(t, "Timing", "event", element.getEvent().get(i), i); 862 if (element.hasRepeat()) 863 composeTimingTimingRepeatComponent(t, "Timing", "repeat", element.getRepeat(), -1); 864 if (element.hasCode()) 865 composeCodeableConcept(t, "Timing", "code", element.getCode(), -1); 866 } 867 868 protected void composeTimingTimingRepeatComponent(Complex parent, String parentType, String name, Timing.TimingRepeatComponent element, int index) { 869 if (element == null) 870 return; 871 Complex t; 872 if (Utilities.noString(parentType)) 873 t = parent; 874 else { 875 t = parent.predicate("fhir:"+parentType+'.'+name); 876 } 877 composeElement(t, "repeat", name, element, index); 878 if (element.hasBounds()) 879 composeType(t, "Timing", "bounds", element.getBounds(), -1); 880 if (element.hasCountElement()) 881 composeInteger(t, "Timing", "count", element.getCountElement(), -1); 882 if (element.hasCountMaxElement()) 883 composeInteger(t, "Timing", "countMax", element.getCountMaxElement(), -1); 884 if (element.hasDurationElement()) 885 composeDecimal(t, "Timing", "duration", element.getDurationElement(), -1); 886 if (element.hasDurationMaxElement()) 887 composeDecimal(t, "Timing", "durationMax", element.getDurationMaxElement(), -1); 888 if (element.hasDurationUnitElement()) 889 composeEnum(t, "Timing", "durationUnit", element.getDurationUnitElement(), -1); 890 if (element.hasFrequencyElement()) 891 composeInteger(t, "Timing", "frequency", element.getFrequencyElement(), -1); 892 if (element.hasFrequencyMaxElement()) 893 composeInteger(t, "Timing", "frequencyMax", element.getFrequencyMaxElement(), -1); 894 if (element.hasPeriodElement()) 895 composeDecimal(t, "Timing", "period", element.getPeriodElement(), -1); 896 if (element.hasPeriodMaxElement()) 897 composeDecimal(t, "Timing", "periodMax", element.getPeriodMaxElement(), -1); 898 if (element.hasPeriodUnitElement()) 899 composeEnum(t, "Timing", "periodUnit", element.getPeriodUnitElement(), -1); 900 for (int i = 0; i < element.getDayOfWeek().size(); i++) 901 composeEnum(t, "Timing", "dayOfWeek", element.getDayOfWeek().get(i), i); 902 for (int i = 0; i < element.getTimeOfDay().size(); i++) 903 composeTime(t, "Timing", "timeOfDay", element.getTimeOfDay().get(i), i); 904 for (int i = 0; i < element.getWhen().size(); i++) 905 composeEnum(t, "Timing", "when", element.getWhen().get(i), i); 906 if (element.hasOffsetElement()) 907 composeUnsignedInt(t, "Timing", "offset", element.getOffsetElement(), -1); 908 } 909 910 protected void composeElementDefinition(Complex parent, String parentType, String name, ElementDefinition element, int index) { 911 if (element == null) 912 return; 913 Complex t; 914 if (Utilities.noString(parentType)) 915 t = parent; 916 else { 917 t = parent.predicate("fhir:"+parentType+'.'+name); 918 } 919 composeElement(t, "ElementDefinition", name, element, index); 920 if (element.hasPathElement()) 921 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 922 for (int i = 0; i < element.getRepresentation().size(); i++) 923 composeEnum(t, "ElementDefinition", "representation", element.getRepresentation().get(i), i); 924 if (element.hasSliceNameElement()) 925 composeString(t, "ElementDefinition", "sliceName", element.getSliceNameElement(), -1); 926 if (element.hasLabelElement()) 927 composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1); 928 for (int i = 0; i < element.getCode().size(); i++) 929 composeCoding(t, "ElementDefinition", "code", element.getCode().get(i), i); 930 if (element.hasSlicing()) 931 composeElementDefinitionElementDefinitionSlicingComponent(t, "ElementDefinition", "slicing", element.getSlicing(), -1); 932 if (element.hasShortElement()) 933 composeString(t, "ElementDefinition", "short", element.getShortElement(), -1); 934 if (element.hasDefinitionElement()) 935 composeMarkdown(t, "ElementDefinition", "definition", element.getDefinitionElement(), -1); 936 if (element.hasCommentElement()) 937 composeMarkdown(t, "ElementDefinition", "comment", element.getCommentElement(), -1); 938 if (element.hasRequirementsElement()) 939 composeMarkdown(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1); 940 for (int i = 0; i < element.getAlias().size(); i++) 941 composeString(t, "ElementDefinition", "alias", element.getAlias().get(i), i); 942 if (element.hasMinElement()) 943 composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1); 944 if (element.hasMaxElement()) 945 composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1); 946 if (element.hasBase()) 947 composeElementDefinitionElementDefinitionBaseComponent(t, "ElementDefinition", "base", element.getBase(), -1); 948 if (element.hasContentReferenceElement()) 949 composeUri(t, "ElementDefinition", "contentReference", element.getContentReferenceElement(), -1); 950 for (int i = 0; i < element.getType().size(); i++) 951 composeElementDefinitionTypeRefComponent(t, "ElementDefinition", "type", element.getType().get(i), i); 952 if (element.hasDefaultValue()) 953 composeType(t, "ElementDefinition", "defaultValue", element.getDefaultValue(), -1); 954 if (element.hasMeaningWhenMissingElement()) 955 composeMarkdown(t, "ElementDefinition", "meaningWhenMissing", element.getMeaningWhenMissingElement(), -1); 956 if (element.hasOrderMeaningElement()) 957 composeString(t, "ElementDefinition", "orderMeaning", element.getOrderMeaningElement(), -1); 958 if (element.hasFixed()) 959 composeType(t, "ElementDefinition", "fixed", element.getFixed(), -1); 960 if (element.hasPattern()) 961 composeType(t, "ElementDefinition", "pattern", element.getPattern(), -1); 962 for (int i = 0; i < element.getExample().size(); i++) 963 composeElementDefinitionElementDefinitionExampleComponent(t, "ElementDefinition", "example", element.getExample().get(i), i); 964 if (element.hasMinValue()) 965 composeType(t, "ElementDefinition", "minValue", element.getMinValue(), -1); 966 if (element.hasMaxValue()) 967 composeType(t, "ElementDefinition", "maxValue", element.getMaxValue(), -1); 968 if (element.hasMaxLengthElement()) 969 composeInteger(t, "ElementDefinition", "maxLength", element.getMaxLengthElement(), -1); 970 for (int i = 0; i < element.getCondition().size(); i++) 971 composeId(t, "ElementDefinition", "condition", element.getCondition().get(i), i); 972 for (int i = 0; i < element.getConstraint().size(); i++) 973 composeElementDefinitionElementDefinitionConstraintComponent(t, "ElementDefinition", "constraint", element.getConstraint().get(i), i); 974 if (element.hasMustSupportElement()) 975 composeBoolean(t, "ElementDefinition", "mustSupport", element.getMustSupportElement(), -1); 976 if (element.hasIsModifierElement()) 977 composeBoolean(t, "ElementDefinition", "isModifier", element.getIsModifierElement(), -1); 978 if (element.hasIsSummaryElement()) 979 composeBoolean(t, "ElementDefinition", "isSummary", element.getIsSummaryElement(), -1); 980 if (element.hasBinding()) 981 composeElementDefinitionElementDefinitionBindingComponent(t, "ElementDefinition", "binding", element.getBinding(), -1); 982 for (int i = 0; i < element.getMapping().size(); i++) 983 composeElementDefinitionElementDefinitionMappingComponent(t, "ElementDefinition", "mapping", element.getMapping().get(i), i); 984 } 985 986 protected void composeElementDefinitionElementDefinitionSlicingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingComponent element, int index) { 987 if (element == null) 988 return; 989 Complex t; 990 if (Utilities.noString(parentType)) 991 t = parent; 992 else { 993 t = parent.predicate("fhir:"+parentType+'.'+name); 994 } 995 composeElement(t, "slicing", name, element, index); 996 for (int i = 0; i < element.getDiscriminator().size(); i++) 997 composeElementDefinitionElementDefinitionSlicingDiscriminatorComponent(t, "ElementDefinition", "discriminator", element.getDiscriminator().get(i), i); 998 if (element.hasDescriptionElement()) 999 composeString(t, "ElementDefinition", "description", element.getDescriptionElement(), -1); 1000 if (element.hasOrderedElement()) 1001 composeBoolean(t, "ElementDefinition", "ordered", element.getOrderedElement(), -1); 1002 if (element.hasRulesElement()) 1003 composeEnum(t, "ElementDefinition", "rules", element.getRulesElement(), -1); 1004 } 1005 1006 protected void composeElementDefinitionElementDefinitionSlicingDiscriminatorComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent 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, "discriminator", name, element, index); 1016 if (element.hasTypeElement()) 1017 composeEnum(t, "ElementDefinition", "type", element.getTypeElement(), -1); 1018 if (element.hasPathElement()) 1019 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 1020 } 1021 1022 protected void composeElementDefinitionElementDefinitionBaseComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBaseComponent element, int index) { 1023 if (element == null) 1024 return; 1025 Complex t; 1026 if (Utilities.noString(parentType)) 1027 t = parent; 1028 else { 1029 t = parent.predicate("fhir:"+parentType+'.'+name); 1030 } 1031 composeElement(t, "base", name, element, index); 1032 if (element.hasPathElement()) 1033 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 1034 if (element.hasMinElement()) 1035 composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1); 1036 if (element.hasMaxElement()) 1037 composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1); 1038 } 1039 1040 protected void composeElementDefinitionTypeRefComponent(Complex parent, String parentType, String name, ElementDefinition.TypeRefComponent element, int index) { 1041 if (element == null) 1042 return; 1043 Complex t; 1044 if (Utilities.noString(parentType)) 1045 t = parent; 1046 else { 1047 t = parent.predicate("fhir:"+parentType+'.'+name); 1048 } 1049 composeElement(t, "type", name, element, index); 1050 if (element.hasCodeElement()) 1051 composeUri(t, "ElementDefinition", "code", element.getCodeElement(), -1); 1052 if (element.hasProfileElement()) 1053 composeUri(t, "ElementDefinition", "profile", element.getProfileElement(), -1); 1054 if (element.hasTargetProfileElement()) 1055 composeUri(t, "ElementDefinition", "targetProfile", element.getTargetProfileElement(), -1); 1056 for (int i = 0; i < element.getAggregation().size(); i++) 1057 composeEnum(t, "ElementDefinition", "aggregation", element.getAggregation().get(i), i); 1058 if (element.hasVersioningElement()) 1059 composeEnum(t, "ElementDefinition", "versioning", element.getVersioningElement(), -1); 1060 } 1061 1062 protected void composeElementDefinitionElementDefinitionExampleComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionExampleComponent element, int index) { 1063 if (element == null) 1064 return; 1065 Complex t; 1066 if (Utilities.noString(parentType)) 1067 t = parent; 1068 else { 1069 t = parent.predicate("fhir:"+parentType+'.'+name); 1070 } 1071 composeElement(t, "example", name, element, index); 1072 if (element.hasLabelElement()) 1073 composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1); 1074 if (element.hasValue()) 1075 composeType(t, "ElementDefinition", "value", element.getValue(), -1); 1076 } 1077 1078 protected void composeElementDefinitionElementDefinitionConstraintComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionConstraintComponent element, int index) { 1079 if (element == null) 1080 return; 1081 Complex t; 1082 if (Utilities.noString(parentType)) 1083 t = parent; 1084 else { 1085 t = parent.predicate("fhir:"+parentType+'.'+name); 1086 } 1087 composeElement(t, "constraint", name, element, index); 1088 if (element.hasKeyElement()) 1089 composeId(t, "ElementDefinition", "key", element.getKeyElement(), -1); 1090 if (element.hasRequirementsElement()) 1091 composeString(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1); 1092 if (element.hasSeverityElement()) 1093 composeEnum(t, "ElementDefinition", "severity", element.getSeverityElement(), -1); 1094 if (element.hasHumanElement()) 1095 composeString(t, "ElementDefinition", "human", element.getHumanElement(), -1); 1096 if (element.hasExpressionElement()) 1097 composeString(t, "ElementDefinition", "expression", element.getExpressionElement(), -1); 1098 if (element.hasXpathElement()) 1099 composeString(t, "ElementDefinition", "xpath", element.getXpathElement(), -1); 1100 if (element.hasSourceElement()) 1101 composeUri(t, "ElementDefinition", "source", element.getSourceElement(), -1); 1102 } 1103 1104 protected void composeElementDefinitionElementDefinitionBindingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingComponent element, int index) { 1105 if (element == null) 1106 return; 1107 Complex t; 1108 if (Utilities.noString(parentType)) 1109 t = parent; 1110 else { 1111 t = parent.predicate("fhir:"+parentType+'.'+name); 1112 } 1113 composeElement(t, "binding", name, element, index); 1114 if (element.hasStrengthElement()) 1115 composeEnum(t, "ElementDefinition", "strength", element.getStrengthElement(), -1); 1116 if (element.hasDescriptionElement()) 1117 composeString(t, "ElementDefinition", "description", element.getDescriptionElement(), -1); 1118 if (element.hasValueSet()) 1119 composeType(t, "ElementDefinition", "valueSet", element.getValueSet(), -1); 1120 } 1121 1122 protected void composeElementDefinitionElementDefinitionMappingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionMappingComponent element, int index) { 1123 if (element == null) 1124 return; 1125 Complex t; 1126 if (Utilities.noString(parentType)) 1127 t = parent; 1128 else { 1129 t = parent.predicate("fhir:"+parentType+'.'+name); 1130 } 1131 composeElement(t, "mapping", name, element, index); 1132 if (element.hasIdentityElement()) 1133 composeId(t, "ElementDefinition", "identity", element.getIdentityElement(), -1); 1134 if (element.hasLanguageElement()) 1135 composeCode(t, "ElementDefinition", "language", element.getLanguageElement(), -1); 1136 if (element.hasMapElement()) 1137 composeString(t, "ElementDefinition", "map", element.getMapElement(), -1); 1138 if (element.hasCommentElement()) 1139 composeString(t, "ElementDefinition", "comment", element.getCommentElement(), -1); 1140 } 1141 1142 protected void composeParameterDefinition(Complex parent, String parentType, String name, ParameterDefinition 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, "ParameterDefinition", name, element, index); 1152 if (element.hasNameElement()) 1153 composeCode(t, "ParameterDefinition", "name", element.getNameElement(), -1); 1154 if (element.hasUseElement()) 1155 composeEnum(t, "ParameterDefinition", "use", element.getUseElement(), -1); 1156 if (element.hasMinElement()) 1157 composeInteger(t, "ParameterDefinition", "min", element.getMinElement(), -1); 1158 if (element.hasMaxElement()) 1159 composeString(t, "ParameterDefinition", "max", element.getMaxElement(), -1); 1160 if (element.hasDocumentationElement()) 1161 composeString(t, "ParameterDefinition", "documentation", element.getDocumentationElement(), -1); 1162 if (element.hasTypeElement()) 1163 composeCode(t, "ParameterDefinition", "type", element.getTypeElement(), -1); 1164 if (element.hasProfile()) 1165 composeReference(t, "ParameterDefinition", "profile", element.getProfile(), -1); 1166 } 1167 1168 protected void composeDomainResource(Complex t, String parentType, String name, DomainResource element, int index) { 1169 composeResource(t, parentType, name, element, index); 1170 if (element.hasText()) 1171 composeNarrative(t, "DomainResource", "text", element.getText(), -1); 1172 for (int i = 0; i < element.getContained().size(); i++) 1173 composeResource(t, "DomainResource", "contained", element.getContained().get(i), i); 1174 for (int i = 0; i < element.getExtension().size(); i++) 1175 composeExtension(t, "DomainResource", "extension", element.getExtension().get(i), i); 1176 for (int i = 0; i < element.getModifierExtension().size(); i++) 1177 composeExtension(t, "DomainResource", "modifierExtension", element.getModifierExtension().get(i), i); 1178 } 1179 1180 protected void composeParameters(Complex parent, String parentType, String name, Parameters element, int index) { 1181 if (element == null) 1182 return; 1183 Complex t; 1184 if (Utilities.noString(parentType)) 1185 t = parent; 1186 else { 1187 t = parent.predicate("fhir:"+parentType+'.'+name); 1188 } 1189 composeResource(t, "Parameters", name, element, index); 1190 for (int i = 0; i < element.getParameter().size(); i++) 1191 composeParametersParametersParameterComponent(t, "Parameters", "parameter", element.getParameter().get(i), i); 1192 } 1193 1194 protected void composeParametersParametersParameterComponent(Complex parent, String parentType, String name, Parameters.ParametersParameterComponent element, int index) { 1195 if (element == null) 1196 return; 1197 Complex t; 1198 if (Utilities.noString(parentType)) 1199 t = parent; 1200 else { 1201 t = parent.predicate("fhir:"+parentType+'.'+name); 1202 } 1203 composeBackboneElement(t, "parameter", name, element, index); 1204 if (element.hasNameElement()) 1205 composeString(t, "Parameters", "name", element.getNameElement(), -1); 1206 if (element.hasValue()) 1207 composeType(t, "Parameters", "value", element.getValue(), -1); 1208 if (element.hasResource()) 1209 composeResource(t, "Parameters", "resource", element.getResource(), -1); 1210 for (int i = 0; i < element.getPart().size(); i++) 1211 composeParametersParametersParameterComponent(t, "Parameters", "part", element.getPart().get(i), i); 1212 } 1213 1214 protected void composeResource(Complex t, String parentType, String name, Resource element, int index) { 1215 if (element.hasIdElement()) 1216 composeId(t, "Resource", "id", element.getIdElement(), -1); 1217 if (element.hasMeta()) 1218 composeMeta(t, "Resource", "meta", element.getMeta(), -1); 1219 if (element.hasImplicitRulesElement()) 1220 composeUri(t, "Resource", "implicitRules", element.getImplicitRulesElement(), -1); 1221 if (element.hasLanguageElement()) 1222 composeCode(t, "Resource", "language", element.getLanguageElement(), -1); 1223 } 1224 1225 protected void composeAccount(Complex parent, String parentType, String name, Account element, int index) { 1226 if (element == null) 1227 return; 1228 Complex t; 1229 if (Utilities.noString(parentType)) 1230 t = parent; 1231 else { 1232 t = parent.predicate("fhir:"+parentType+'.'+name); 1233 } 1234 composeDomainResource(t, "Account", name, element, index); 1235 for (int i = 0; i < element.getIdentifier().size(); i++) 1236 composeIdentifier(t, "Account", "identifier", element.getIdentifier().get(i), i); 1237 if (element.hasStatusElement()) 1238 composeEnum(t, "Account", "status", element.getStatusElement(), -1); 1239 if (element.hasType()) 1240 composeCodeableConcept(t, "Account", "type", element.getType(), -1); 1241 if (element.hasNameElement()) 1242 composeString(t, "Account", "name", element.getNameElement(), -1); 1243 if (element.hasSubject()) 1244 composeReference(t, "Account", "subject", element.getSubject(), -1); 1245 if (element.hasPeriod()) 1246 composePeriod(t, "Account", "period", element.getPeriod(), -1); 1247 if (element.hasActive()) 1248 composePeriod(t, "Account", "active", element.getActive(), -1); 1249 if (element.hasBalance()) 1250 composeMoney(t, "Account", "balance", element.getBalance(), -1); 1251 for (int i = 0; i < element.getCoverage().size(); i++) 1252 composeAccountCoverageComponent(t, "Account", "coverage", element.getCoverage().get(i), i); 1253 if (element.hasOwner()) 1254 composeReference(t, "Account", "owner", element.getOwner(), -1); 1255 if (element.hasDescriptionElement()) 1256 composeString(t, "Account", "description", element.getDescriptionElement(), -1); 1257 for (int i = 0; i < element.getGuarantor().size(); i++) 1258 composeAccountGuarantorComponent(t, "Account", "guarantor", element.getGuarantor().get(i), i); 1259 } 1260 1261 protected void composeAccountCoverageComponent(Complex parent, String parentType, String name, Account.CoverageComponent element, int index) { 1262 if (element == null) 1263 return; 1264 Complex t; 1265 if (Utilities.noString(parentType)) 1266 t = parent; 1267 else { 1268 t = parent.predicate("fhir:"+parentType+'.'+name); 1269 } 1270 composeBackboneElement(t, "coverage", name, element, index); 1271 if (element.hasCoverage()) 1272 composeReference(t, "Account", "coverage", element.getCoverage(), -1); 1273 if (element.hasPriorityElement()) 1274 composePositiveInt(t, "Account", "priority", element.getPriorityElement(), -1); 1275 } 1276 1277 protected void composeAccountGuarantorComponent(Complex parent, String parentType, String name, Account.GuarantorComponent element, int index) { 1278 if (element == null) 1279 return; 1280 Complex t; 1281 if (Utilities.noString(parentType)) 1282 t = parent; 1283 else { 1284 t = parent.predicate("fhir:"+parentType+'.'+name); 1285 } 1286 composeBackboneElement(t, "guarantor", name, element, index); 1287 if (element.hasParty()) 1288 composeReference(t, "Account", "party", element.getParty(), -1); 1289 if (element.hasOnHoldElement()) 1290 composeBoolean(t, "Account", "onHold", element.getOnHoldElement(), -1); 1291 if (element.hasPeriod()) 1292 composePeriod(t, "Account", "period", element.getPeriod(), -1); 1293 } 1294 1295 protected void composeActivityDefinition(Complex parent, String parentType, String name, ActivityDefinition element, int index) { 1296 if (element == null) 1297 return; 1298 Complex t; 1299 if (Utilities.noString(parentType)) 1300 t = parent; 1301 else { 1302 t = parent.predicate("fhir:"+parentType+'.'+name); 1303 } 1304 composeDomainResource(t, "ActivityDefinition", name, element, index); 1305 if (element.hasUrlElement()) 1306 composeUri(t, "ActivityDefinition", "url", element.getUrlElement(), -1); 1307 for (int i = 0; i < element.getIdentifier().size(); i++) 1308 composeIdentifier(t, "ActivityDefinition", "identifier", element.getIdentifier().get(i), i); 1309 if (element.hasVersionElement()) 1310 composeString(t, "ActivityDefinition", "version", element.getVersionElement(), -1); 1311 if (element.hasNameElement()) 1312 composeString(t, "ActivityDefinition", "name", element.getNameElement(), -1); 1313 if (element.hasTitleElement()) 1314 composeString(t, "ActivityDefinition", "title", element.getTitleElement(), -1); 1315 if (element.hasStatusElement()) 1316 composeEnum(t, "ActivityDefinition", "status", element.getStatusElement(), -1); 1317 if (element.hasExperimentalElement()) 1318 composeBoolean(t, "ActivityDefinition", "experimental", element.getExperimentalElement(), -1); 1319 if (element.hasDateElement()) 1320 composeDateTime(t, "ActivityDefinition", "date", element.getDateElement(), -1); 1321 if (element.hasPublisherElement()) 1322 composeString(t, "ActivityDefinition", "publisher", element.getPublisherElement(), -1); 1323 if (element.hasDescriptionElement()) 1324 composeMarkdown(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1); 1325 if (element.hasPurposeElement()) 1326 composeMarkdown(t, "ActivityDefinition", "purpose", element.getPurposeElement(), -1); 1327 if (element.hasUsageElement()) 1328 composeString(t, "ActivityDefinition", "usage", element.getUsageElement(), -1); 1329 if (element.hasApprovalDateElement()) 1330 composeDate(t, "ActivityDefinition", "approvalDate", element.getApprovalDateElement(), -1); 1331 if (element.hasLastReviewDateElement()) 1332 composeDate(t, "ActivityDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 1333 if (element.hasEffectivePeriod()) 1334 composePeriod(t, "ActivityDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 1335 for (int i = 0; i < element.getUseContext().size(); i++) 1336 composeUsageContext(t, "ActivityDefinition", "useContext", element.getUseContext().get(i), i); 1337 for (int i = 0; i < element.getJurisdiction().size(); i++) 1338 composeCodeableConcept(t, "ActivityDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 1339 for (int i = 0; i < element.getTopic().size(); i++) 1340 composeCodeableConcept(t, "ActivityDefinition", "topic", element.getTopic().get(i), i); 1341 for (int i = 0; i < element.getContributor().size(); i++) 1342 composeContributor(t, "ActivityDefinition", "contributor", element.getContributor().get(i), i); 1343 for (int i = 0; i < element.getContact().size(); i++) 1344 composeContactDetail(t, "ActivityDefinition", "contact", element.getContact().get(i), i); 1345 if (element.hasCopyrightElement()) 1346 composeMarkdown(t, "ActivityDefinition", "copyright", element.getCopyrightElement(), -1); 1347 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 1348 composeRelatedArtifact(t, "ActivityDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 1349 for (int i = 0; i < element.getLibrary().size(); i++) 1350 composeReference(t, "ActivityDefinition", "library", element.getLibrary().get(i), i); 1351 if (element.hasKindElement()) 1352 composeEnum(t, "ActivityDefinition", "kind", element.getKindElement(), -1); 1353 if (element.hasCode()) 1354 composeCodeableConcept(t, "ActivityDefinition", "code", element.getCode(), -1); 1355 if (element.hasTiming()) 1356 composeType(t, "ActivityDefinition", "timing", element.getTiming(), -1); 1357 if (element.hasLocation()) 1358 composeReference(t, "ActivityDefinition", "location", element.getLocation(), -1); 1359 for (int i = 0; i < element.getParticipant().size(); i++) 1360 composeActivityDefinitionActivityDefinitionParticipantComponent(t, "ActivityDefinition", "participant", element.getParticipant().get(i), i); 1361 if (element.hasProduct()) 1362 composeType(t, "ActivityDefinition", "product", element.getProduct(), -1); 1363 if (element.hasQuantity()) 1364 composeQuantity(t, "ActivityDefinition", "quantity", element.getQuantity(), -1); 1365 for (int i = 0; i < element.getDosage().size(); i++) 1366 composeDosage(t, "ActivityDefinition", "dosage", element.getDosage().get(i), i); 1367 for (int i = 0; i < element.getBodySite().size(); i++) 1368 composeCodeableConcept(t, "ActivityDefinition", "bodySite", element.getBodySite().get(i), i); 1369 if (element.hasTransform()) 1370 composeReference(t, "ActivityDefinition", "transform", element.getTransform(), -1); 1371 for (int i = 0; i < element.getDynamicValue().size(); i++) 1372 composeActivityDefinitionActivityDefinitionDynamicValueComponent(t, "ActivityDefinition", "dynamicValue", element.getDynamicValue().get(i), i); 1373 } 1374 1375 protected void composeActivityDefinitionActivityDefinitionParticipantComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionParticipantComponent element, int index) { 1376 if (element == null) 1377 return; 1378 Complex t; 1379 if (Utilities.noString(parentType)) 1380 t = parent; 1381 else { 1382 t = parent.predicate("fhir:"+parentType+'.'+name); 1383 } 1384 composeBackboneElement(t, "participant", name, element, index); 1385 if (element.hasTypeElement()) 1386 composeEnum(t, "ActivityDefinition", "type", element.getTypeElement(), -1); 1387 if (element.hasRole()) 1388 composeCodeableConcept(t, "ActivityDefinition", "role", element.getRole(), -1); 1389 } 1390 1391 protected void composeActivityDefinitionActivityDefinitionDynamicValueComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionDynamicValueComponent element, int index) { 1392 if (element == null) 1393 return; 1394 Complex t; 1395 if (Utilities.noString(parentType)) 1396 t = parent; 1397 else { 1398 t = parent.predicate("fhir:"+parentType+'.'+name); 1399 } 1400 composeBackboneElement(t, "dynamicValue", name, element, index); 1401 if (element.hasDescriptionElement()) 1402 composeString(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1); 1403 if (element.hasPathElement()) 1404 composeString(t, "ActivityDefinition", "path", element.getPathElement(), -1); 1405 if (element.hasLanguageElement()) 1406 composeString(t, "ActivityDefinition", "language", element.getLanguageElement(), -1); 1407 if (element.hasExpressionElement()) 1408 composeString(t, "ActivityDefinition", "expression", element.getExpressionElement(), -1); 1409 } 1410 1411 protected void composeAdverseEvent(Complex parent, String parentType, String name, AdverseEvent 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 composeDomainResource(t, "AdverseEvent", name, element, index); 1421 if (element.hasIdentifier()) 1422 composeIdentifier(t, "AdverseEvent", "identifier", element.getIdentifier(), -1); 1423 if (element.hasCategoryElement()) 1424 composeEnum(t, "AdverseEvent", "category", element.getCategoryElement(), -1); 1425 if (element.hasType()) 1426 composeCodeableConcept(t, "AdverseEvent", "type", element.getType(), -1); 1427 if (element.hasSubject()) 1428 composeReference(t, "AdverseEvent", "subject", element.getSubject(), -1); 1429 if (element.hasDateElement()) 1430 composeDateTime(t, "AdverseEvent", "date", element.getDateElement(), -1); 1431 for (int i = 0; i < element.getReaction().size(); i++) 1432 composeReference(t, "AdverseEvent", "reaction", element.getReaction().get(i), i); 1433 if (element.hasLocation()) 1434 composeReference(t, "AdverseEvent", "location", element.getLocation(), -1); 1435 if (element.hasSeriousness()) 1436 composeCodeableConcept(t, "AdverseEvent", "seriousness", element.getSeriousness(), -1); 1437 if (element.hasOutcome()) 1438 composeCodeableConcept(t, "AdverseEvent", "outcome", element.getOutcome(), -1); 1439 if (element.hasRecorder()) 1440 composeReference(t, "AdverseEvent", "recorder", element.getRecorder(), -1); 1441 if (element.hasEventParticipant()) 1442 composeReference(t, "AdverseEvent", "eventParticipant", element.getEventParticipant(), -1); 1443 if (element.hasDescriptionElement()) 1444 composeString(t, "AdverseEvent", "description", element.getDescriptionElement(), -1); 1445 for (int i = 0; i < element.getSuspectEntity().size(); i++) 1446 composeAdverseEventAdverseEventSuspectEntityComponent(t, "AdverseEvent", "suspectEntity", element.getSuspectEntity().get(i), i); 1447 for (int i = 0; i < element.getSubjectMedicalHistory().size(); i++) 1448 composeReference(t, "AdverseEvent", "subjectMedicalHistory", element.getSubjectMedicalHistory().get(i), i); 1449 for (int i = 0; i < element.getReferenceDocument().size(); i++) 1450 composeReference(t, "AdverseEvent", "referenceDocument", element.getReferenceDocument().get(i), i); 1451 for (int i = 0; i < element.getStudy().size(); i++) 1452 composeReference(t, "AdverseEvent", "study", element.getStudy().get(i), i); 1453 } 1454 1455 protected void composeAdverseEventAdverseEventSuspectEntityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityComponent element, int index) { 1456 if (element == null) 1457 return; 1458 Complex t; 1459 if (Utilities.noString(parentType)) 1460 t = parent; 1461 else { 1462 t = parent.predicate("fhir:"+parentType+'.'+name); 1463 } 1464 composeBackboneElement(t, "suspectEntity", name, element, index); 1465 if (element.hasInstance()) 1466 composeReference(t, "AdverseEvent", "instance", element.getInstance(), -1); 1467 if (element.hasCausalityElement()) 1468 composeEnum(t, "AdverseEvent", "causality", element.getCausalityElement(), -1); 1469 if (element.hasCausalityAssessment()) 1470 composeCodeableConcept(t, "AdverseEvent", "causalityAssessment", element.getCausalityAssessment(), -1); 1471 if (element.hasCausalityProductRelatednessElement()) 1472 composeString(t, "AdverseEvent", "causalityProductRelatedness", element.getCausalityProductRelatednessElement(), -1); 1473 if (element.hasCausalityMethod()) 1474 composeCodeableConcept(t, "AdverseEvent", "causalityMethod", element.getCausalityMethod(), -1); 1475 if (element.hasCausalityAuthor()) 1476 composeReference(t, "AdverseEvent", "causalityAuthor", element.getCausalityAuthor(), -1); 1477 if (element.hasCausalityResult()) 1478 composeCodeableConcept(t, "AdverseEvent", "causalityResult", element.getCausalityResult(), -1); 1479 } 1480 1481 protected void composeAllergyIntolerance(Complex parent, String parentType, String name, AllergyIntolerance element, int index) { 1482 if (element == null) 1483 return; 1484 Complex t; 1485 if (Utilities.noString(parentType)) 1486 t = parent; 1487 else { 1488 t = parent.predicate("fhir:"+parentType+'.'+name); 1489 } 1490 composeDomainResource(t, "AllergyIntolerance", name, element, index); 1491 for (int i = 0; i < element.getIdentifier().size(); i++) 1492 composeIdentifier(t, "AllergyIntolerance", "identifier", element.getIdentifier().get(i), i); 1493 if (element.hasClinicalStatusElement()) 1494 composeEnum(t, "AllergyIntolerance", "clinicalStatus", element.getClinicalStatusElement(), -1); 1495 if (element.hasVerificationStatusElement()) 1496 composeEnum(t, "AllergyIntolerance", "verificationStatus", element.getVerificationStatusElement(), -1); 1497 if (element.hasTypeElement()) 1498 composeEnum(t, "AllergyIntolerance", "type", element.getTypeElement(), -1); 1499 for (int i = 0; i < element.getCategory().size(); i++) 1500 composeEnum(t, "AllergyIntolerance", "category", element.getCategory().get(i), i); 1501 if (element.hasCriticalityElement()) 1502 composeEnum(t, "AllergyIntolerance", "criticality", element.getCriticalityElement(), -1); 1503 if (element.hasCode()) 1504 composeCodeableConcept(t, "AllergyIntolerance", "code", element.getCode(), -1); 1505 if (element.hasPatient()) 1506 composeReference(t, "AllergyIntolerance", "patient", element.getPatient(), -1); 1507 if (element.hasOnset()) 1508 composeType(t, "AllergyIntolerance", "onset", element.getOnset(), -1); 1509 if (element.hasAssertedDateElement()) 1510 composeDateTime(t, "AllergyIntolerance", "assertedDate", element.getAssertedDateElement(), -1); 1511 if (element.hasRecorder()) 1512 composeReference(t, "AllergyIntolerance", "recorder", element.getRecorder(), -1); 1513 if (element.hasAsserter()) 1514 composeReference(t, "AllergyIntolerance", "asserter", element.getAsserter(), -1); 1515 if (element.hasLastOccurrenceElement()) 1516 composeDateTime(t, "AllergyIntolerance", "lastOccurrence", element.getLastOccurrenceElement(), -1); 1517 for (int i = 0; i < element.getNote().size(); i++) 1518 composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i); 1519 for (int i = 0; i < element.getReaction().size(); i++) 1520 composeAllergyIntoleranceAllergyIntoleranceReactionComponent(t, "AllergyIntolerance", "reaction", element.getReaction().get(i), i); 1521 } 1522 1523 protected void composeAllergyIntoleranceAllergyIntoleranceReactionComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceReactionComponent element, int index) { 1524 if (element == null) 1525 return; 1526 Complex t; 1527 if (Utilities.noString(parentType)) 1528 t = parent; 1529 else { 1530 t = parent.predicate("fhir:"+parentType+'.'+name); 1531 } 1532 composeBackboneElement(t, "reaction", name, element, index); 1533 if (element.hasSubstance()) 1534 composeCodeableConcept(t, "AllergyIntolerance", "substance", element.getSubstance(), -1); 1535 for (int i = 0; i < element.getManifestation().size(); i++) 1536 composeCodeableConcept(t, "AllergyIntolerance", "manifestation", element.getManifestation().get(i), i); 1537 if (element.hasDescriptionElement()) 1538 composeString(t, "AllergyIntolerance", "description", element.getDescriptionElement(), -1); 1539 if (element.hasOnsetElement()) 1540 composeDateTime(t, "AllergyIntolerance", "onset", element.getOnsetElement(), -1); 1541 if (element.hasSeverityElement()) 1542 composeEnum(t, "AllergyIntolerance", "severity", element.getSeverityElement(), -1); 1543 if (element.hasExposureRoute()) 1544 composeCodeableConcept(t, "AllergyIntolerance", "exposureRoute", element.getExposureRoute(), -1); 1545 for (int i = 0; i < element.getNote().size(); i++) 1546 composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i); 1547 } 1548 1549 protected void composeAppointment(Complex parent, String parentType, String name, Appointment element, int index) { 1550 if (element == null) 1551 return; 1552 Complex t; 1553 if (Utilities.noString(parentType)) 1554 t = parent; 1555 else { 1556 t = parent.predicate("fhir:"+parentType+'.'+name); 1557 } 1558 composeDomainResource(t, "Appointment", name, element, index); 1559 for (int i = 0; i < element.getIdentifier().size(); i++) 1560 composeIdentifier(t, "Appointment", "identifier", element.getIdentifier().get(i), i); 1561 if (element.hasStatusElement()) 1562 composeEnum(t, "Appointment", "status", element.getStatusElement(), -1); 1563 if (element.hasServiceCategory()) 1564 composeCodeableConcept(t, "Appointment", "serviceCategory", element.getServiceCategory(), -1); 1565 for (int i = 0; i < element.getServiceType().size(); i++) 1566 composeCodeableConcept(t, "Appointment", "serviceType", element.getServiceType().get(i), i); 1567 for (int i = 0; i < element.getSpecialty().size(); i++) 1568 composeCodeableConcept(t, "Appointment", "specialty", element.getSpecialty().get(i), i); 1569 if (element.hasAppointmentType()) 1570 composeCodeableConcept(t, "Appointment", "appointmentType", element.getAppointmentType(), -1); 1571 for (int i = 0; i < element.getReason().size(); i++) 1572 composeCodeableConcept(t, "Appointment", "reason", element.getReason().get(i), i); 1573 for (int i = 0; i < element.getIndication().size(); i++) 1574 composeReference(t, "Appointment", "indication", element.getIndication().get(i), i); 1575 if (element.hasPriorityElement()) 1576 composeUnsignedInt(t, "Appointment", "priority", element.getPriorityElement(), -1); 1577 if (element.hasDescriptionElement()) 1578 composeString(t, "Appointment", "description", element.getDescriptionElement(), -1); 1579 for (int i = 0; i < element.getSupportingInformation().size(); i++) 1580 composeReference(t, "Appointment", "supportingInformation", element.getSupportingInformation().get(i), i); 1581 if (element.hasStartElement()) 1582 composeInstant(t, "Appointment", "start", element.getStartElement(), -1); 1583 if (element.hasEndElement()) 1584 composeInstant(t, "Appointment", "end", element.getEndElement(), -1); 1585 if (element.hasMinutesDurationElement()) 1586 composePositiveInt(t, "Appointment", "minutesDuration", element.getMinutesDurationElement(), -1); 1587 for (int i = 0; i < element.getSlot().size(); i++) 1588 composeReference(t, "Appointment", "slot", element.getSlot().get(i), i); 1589 if (element.hasCreatedElement()) 1590 composeDateTime(t, "Appointment", "created", element.getCreatedElement(), -1); 1591 if (element.hasCommentElement()) 1592 composeString(t, "Appointment", "comment", element.getCommentElement(), -1); 1593 for (int i = 0; i < element.getIncomingReferral().size(); i++) 1594 composeReference(t, "Appointment", "incomingReferral", element.getIncomingReferral().get(i), i); 1595 for (int i = 0; i < element.getParticipant().size(); i++) 1596 composeAppointmentAppointmentParticipantComponent(t, "Appointment", "participant", element.getParticipant().get(i), i); 1597 for (int i = 0; i < element.getRequestedPeriod().size(); i++) 1598 composePeriod(t, "Appointment", "requestedPeriod", element.getRequestedPeriod().get(i), i); 1599 } 1600 1601 protected void composeAppointmentAppointmentParticipantComponent(Complex parent, String parentType, String name, Appointment.AppointmentParticipantComponent element, int index) { 1602 if (element == null) 1603 return; 1604 Complex t; 1605 if (Utilities.noString(parentType)) 1606 t = parent; 1607 else { 1608 t = parent.predicate("fhir:"+parentType+'.'+name); 1609 } 1610 composeBackboneElement(t, "participant", name, element, index); 1611 for (int i = 0; i < element.getType().size(); i++) 1612 composeCodeableConcept(t, "Appointment", "type", element.getType().get(i), i); 1613 if (element.hasActor()) 1614 composeReference(t, "Appointment", "actor", element.getActor(), -1); 1615 if (element.hasRequiredElement()) 1616 composeEnum(t, "Appointment", "required", element.getRequiredElement(), -1); 1617 if (element.hasStatusElement()) 1618 composeEnum(t, "Appointment", "status", element.getStatusElement(), -1); 1619 } 1620 1621 protected void composeAppointmentResponse(Complex parent, String parentType, String name, AppointmentResponse 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 composeDomainResource(t, "AppointmentResponse", name, element, index); 1631 for (int i = 0; i < element.getIdentifier().size(); i++) 1632 composeIdentifier(t, "AppointmentResponse", "identifier", element.getIdentifier().get(i), i); 1633 if (element.hasAppointment()) 1634 composeReference(t, "AppointmentResponse", "appointment", element.getAppointment(), -1); 1635 if (element.hasStartElement()) 1636 composeInstant(t, "AppointmentResponse", "start", element.getStartElement(), -1); 1637 if (element.hasEndElement()) 1638 composeInstant(t, "AppointmentResponse", "end", element.getEndElement(), -1); 1639 for (int i = 0; i < element.getParticipantType().size(); i++) 1640 composeCodeableConcept(t, "AppointmentResponse", "participantType", element.getParticipantType().get(i), i); 1641 if (element.hasActor()) 1642 composeReference(t, "AppointmentResponse", "actor", element.getActor(), -1); 1643 if (element.hasParticipantStatusElement()) 1644 composeEnum(t, "AppointmentResponse", "participantStatus", element.getParticipantStatusElement(), -1); 1645 if (element.hasCommentElement()) 1646 composeString(t, "AppointmentResponse", "comment", element.getCommentElement(), -1); 1647 } 1648 1649 protected void composeAuditEvent(Complex parent, String parentType, String name, AuditEvent element, int index) { 1650 if (element == null) 1651 return; 1652 Complex t; 1653 if (Utilities.noString(parentType)) 1654 t = parent; 1655 else { 1656 t = parent.predicate("fhir:"+parentType+'.'+name); 1657 } 1658 composeDomainResource(t, "AuditEvent", name, element, index); 1659 if (element.hasType()) 1660 composeCoding(t, "AuditEvent", "type", element.getType(), -1); 1661 for (int i = 0; i < element.getSubtype().size(); i++) 1662 composeCoding(t, "AuditEvent", "subtype", element.getSubtype().get(i), i); 1663 if (element.hasActionElement()) 1664 composeEnum(t, "AuditEvent", "action", element.getActionElement(), -1); 1665 if (element.hasRecordedElement()) 1666 composeInstant(t, "AuditEvent", "recorded", element.getRecordedElement(), -1); 1667 if (element.hasOutcomeElement()) 1668 composeEnum(t, "AuditEvent", "outcome", element.getOutcomeElement(), -1); 1669 if (element.hasOutcomeDescElement()) 1670 composeString(t, "AuditEvent", "outcomeDesc", element.getOutcomeDescElement(), -1); 1671 for (int i = 0; i < element.getPurposeOfEvent().size(); i++) 1672 composeCodeableConcept(t, "AuditEvent", "purposeOfEvent", element.getPurposeOfEvent().get(i), i); 1673 for (int i = 0; i < element.getAgent().size(); i++) 1674 composeAuditEventAuditEventAgentComponent(t, "AuditEvent", "agent", element.getAgent().get(i), i); 1675 if (element.hasSource()) 1676 composeAuditEventAuditEventSourceComponent(t, "AuditEvent", "source", element.getSource(), -1); 1677 for (int i = 0; i < element.getEntity().size(); i++) 1678 composeAuditEventAuditEventEntityComponent(t, "AuditEvent", "entity", element.getEntity().get(i), i); 1679 } 1680 1681 protected void composeAuditEventAuditEventAgentComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentComponent element, int index) { 1682 if (element == null) 1683 return; 1684 Complex t; 1685 if (Utilities.noString(parentType)) 1686 t = parent; 1687 else { 1688 t = parent.predicate("fhir:"+parentType+'.'+name); 1689 } 1690 composeBackboneElement(t, "agent", name, element, index); 1691 for (int i = 0; i < element.getRole().size(); i++) 1692 composeCodeableConcept(t, "AuditEvent", "role", element.getRole().get(i), i); 1693 if (element.hasReference()) 1694 composeReference(t, "AuditEvent", "reference", element.getReference(), -1); 1695 if (element.hasUserId()) 1696 composeIdentifier(t, "AuditEvent", "userId", element.getUserId(), -1); 1697 if (element.hasAltIdElement()) 1698 composeString(t, "AuditEvent", "altId", element.getAltIdElement(), -1); 1699 if (element.hasNameElement()) 1700 composeString(t, "AuditEvent", "name", element.getNameElement(), -1); 1701 if (element.hasRequestorElement()) 1702 composeBoolean(t, "AuditEvent", "requestor", element.getRequestorElement(), -1); 1703 if (element.hasLocation()) 1704 composeReference(t, "AuditEvent", "location", element.getLocation(), -1); 1705 for (int i = 0; i < element.getPolicy().size(); i++) 1706 composeUri(t, "AuditEvent", "policy", element.getPolicy().get(i), i); 1707 if (element.hasMedia()) 1708 composeCoding(t, "AuditEvent", "media", element.getMedia(), -1); 1709 if (element.hasNetwork()) 1710 composeAuditEventAuditEventAgentNetworkComponent(t, "AuditEvent", "network", element.getNetwork(), -1); 1711 for (int i = 0; i < element.getPurposeOfUse().size(); i++) 1712 composeCodeableConcept(t, "AuditEvent", "purposeOfUse", element.getPurposeOfUse().get(i), i); 1713 } 1714 1715 protected void composeAuditEventAuditEventAgentNetworkComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentNetworkComponent element, int index) { 1716 if (element == null) 1717 return; 1718 Complex t; 1719 if (Utilities.noString(parentType)) 1720 t = parent; 1721 else { 1722 t = parent.predicate("fhir:"+parentType+'.'+name); 1723 } 1724 composeBackboneElement(t, "network", name, element, index); 1725 if (element.hasAddressElement()) 1726 composeString(t, "AuditEvent", "address", element.getAddressElement(), -1); 1727 if (element.hasTypeElement()) 1728 composeEnum(t, "AuditEvent", "type", element.getTypeElement(), -1); 1729 } 1730 1731 protected void composeAuditEventAuditEventSourceComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventSourceComponent element, int index) { 1732 if (element == null) 1733 return; 1734 Complex t; 1735 if (Utilities.noString(parentType)) 1736 t = parent; 1737 else { 1738 t = parent.predicate("fhir:"+parentType+'.'+name); 1739 } 1740 composeBackboneElement(t, "source", name, element, index); 1741 if (element.hasSiteElement()) 1742 composeString(t, "AuditEvent", "site", element.getSiteElement(), -1); 1743 if (element.hasIdentifier()) 1744 composeIdentifier(t, "AuditEvent", "identifier", element.getIdentifier(), -1); 1745 for (int i = 0; i < element.getType().size(); i++) 1746 composeCoding(t, "AuditEvent", "type", element.getType().get(i), i); 1747 } 1748 1749 protected void composeAuditEventAuditEventEntityComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityComponent element, int index) { 1750 if (element == null) 1751 return; 1752 Complex t; 1753 if (Utilities.noString(parentType)) 1754 t = parent; 1755 else { 1756 t = parent.predicate("fhir:"+parentType+'.'+name); 1757 } 1758 composeBackboneElement(t, "entity", name, element, index); 1759 if (element.hasIdentifier()) 1760 composeIdentifier(t, "AuditEvent", "identifier", element.getIdentifier(), -1); 1761 if (element.hasReference()) 1762 composeReference(t, "AuditEvent", "reference", element.getReference(), -1); 1763 if (element.hasType()) 1764 composeCoding(t, "AuditEvent", "type", element.getType(), -1); 1765 if (element.hasRole()) 1766 composeCoding(t, "AuditEvent", "role", element.getRole(), -1); 1767 if (element.hasLifecycle()) 1768 composeCoding(t, "AuditEvent", "lifecycle", element.getLifecycle(), -1); 1769 for (int i = 0; i < element.getSecurityLabel().size(); i++) 1770 composeCoding(t, "AuditEvent", "securityLabel", element.getSecurityLabel().get(i), i); 1771 if (element.hasNameElement()) 1772 composeString(t, "AuditEvent", "name", element.getNameElement(), -1); 1773 if (element.hasDescriptionElement()) 1774 composeString(t, "AuditEvent", "description", element.getDescriptionElement(), -1); 1775 if (element.hasQueryElement()) 1776 composeBase64Binary(t, "AuditEvent", "query", element.getQueryElement(), -1); 1777 for (int i = 0; i < element.getDetail().size(); i++) 1778 composeAuditEventAuditEventEntityDetailComponent(t, "AuditEvent", "detail", element.getDetail().get(i), i); 1779 } 1780 1781 protected void composeAuditEventAuditEventEntityDetailComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityDetailComponent element, int index) { 1782 if (element == null) 1783 return; 1784 Complex t; 1785 if (Utilities.noString(parentType)) 1786 t = parent; 1787 else { 1788 t = parent.predicate("fhir:"+parentType+'.'+name); 1789 } 1790 composeBackboneElement(t, "detail", name, element, index); 1791 if (element.hasTypeElement()) 1792 composeString(t, "AuditEvent", "type", element.getTypeElement(), -1); 1793 if (element.hasValueElement()) 1794 composeBase64Binary(t, "AuditEvent", "value", element.getValueElement(), -1); 1795 } 1796 1797 protected void composeBasic(Complex parent, String parentType, String name, Basic element, int index) { 1798 if (element == null) 1799 return; 1800 Complex t; 1801 if (Utilities.noString(parentType)) 1802 t = parent; 1803 else { 1804 t = parent.predicate("fhir:"+parentType+'.'+name); 1805 } 1806 composeDomainResource(t, "Basic", name, element, index); 1807 for (int i = 0; i < element.getIdentifier().size(); i++) 1808 composeIdentifier(t, "Basic", "identifier", element.getIdentifier().get(i), i); 1809 if (element.hasCode()) 1810 composeCodeableConcept(t, "Basic", "code", element.getCode(), -1); 1811 if (element.hasSubject()) 1812 composeReference(t, "Basic", "subject", element.getSubject(), -1); 1813 if (element.hasCreatedElement()) 1814 composeDate(t, "Basic", "created", element.getCreatedElement(), -1); 1815 if (element.hasAuthor()) 1816 composeReference(t, "Basic", "author", element.getAuthor(), -1); 1817 } 1818 1819 protected void composeBinary(Complex parent, String parentType, String name, Binary element, int index) { 1820 if (element == null) 1821 return; 1822 Complex t; 1823 if (Utilities.noString(parentType)) 1824 t = parent; 1825 else { 1826 t = parent.predicate("fhir:"+parentType+'.'+name); 1827 } 1828 composeResource(t, "Binary", name, element, index); 1829 if (element.hasContentTypeElement()) 1830 composeCode(t, "Binary", "contentType", element.getContentTypeElement(), -1); 1831 if (element.hasSecurityContext()) 1832 composeReference(t, "Binary", "securityContext", element.getSecurityContext(), -1); 1833 if (element.hasContentElement()) 1834 composeBase64Binary(t, "Binary", "content", element.getContentElement(), -1); 1835 } 1836 1837 protected void composeBodySite(Complex parent, String parentType, String name, BodySite element, int index) { 1838 if (element == null) 1839 return; 1840 Complex t; 1841 if (Utilities.noString(parentType)) 1842 t = parent; 1843 else { 1844 t = parent.predicate("fhir:"+parentType+'.'+name); 1845 } 1846 composeDomainResource(t, "BodySite", name, element, index); 1847 for (int i = 0; i < element.getIdentifier().size(); i++) 1848 composeIdentifier(t, "BodySite", "identifier", element.getIdentifier().get(i), i); 1849 if (element.hasActiveElement()) 1850 composeBoolean(t, "BodySite", "active", element.getActiveElement(), -1); 1851 if (element.hasCode()) 1852 composeCodeableConcept(t, "BodySite", "code", element.getCode(), -1); 1853 for (int i = 0; i < element.getQualifier().size(); i++) 1854 composeCodeableConcept(t, "BodySite", "qualifier", element.getQualifier().get(i), i); 1855 if (element.hasDescriptionElement()) 1856 composeString(t, "BodySite", "description", element.getDescriptionElement(), -1); 1857 for (int i = 0; i < element.getImage().size(); i++) 1858 composeAttachment(t, "BodySite", "image", element.getImage().get(i), i); 1859 if (element.hasPatient()) 1860 composeReference(t, "BodySite", "patient", element.getPatient(), -1); 1861 } 1862 1863 protected void composeBundle(Complex parent, String parentType, String name, Bundle element, int index) { 1864 if (element == null) 1865 return; 1866 Complex t; 1867 if (Utilities.noString(parentType)) 1868 t = parent; 1869 else { 1870 t = parent.predicate("fhir:"+parentType+'.'+name); 1871 } 1872 composeResource(t, "Bundle", name, element, index); 1873 if (element.hasIdentifier()) 1874 composeIdentifier(t, "Bundle", "identifier", element.getIdentifier(), -1); 1875 if (element.hasTypeElement()) 1876 composeEnum(t, "Bundle", "type", element.getTypeElement(), -1); 1877 if (element.hasTotalElement()) 1878 composeUnsignedInt(t, "Bundle", "total", element.getTotalElement(), -1); 1879 for (int i = 0; i < element.getLink().size(); i++) 1880 composeBundleBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i); 1881 for (int i = 0; i < element.getEntry().size(); i++) 1882 composeBundleBundleEntryComponent(t, "Bundle", "entry", element.getEntry().get(i), i); 1883 if (element.hasSignature()) 1884 composeSignature(t, "Bundle", "signature", element.getSignature(), -1); 1885 } 1886 1887 protected void composeBundleBundleLinkComponent(Complex parent, String parentType, String name, Bundle.BundleLinkComponent element, int index) { 1888 if (element == null) 1889 return; 1890 Complex t; 1891 if (Utilities.noString(parentType)) 1892 t = parent; 1893 else { 1894 t = parent.predicate("fhir:"+parentType+'.'+name); 1895 } 1896 composeBackboneElement(t, "link", name, element, index); 1897 if (element.hasRelationElement()) 1898 composeString(t, "Bundle", "relation", element.getRelationElement(), -1); 1899 if (element.hasUrlElement()) 1900 composeUri(t, "Bundle", "url", element.getUrlElement(), -1); 1901 } 1902 1903 protected void composeBundleBundleEntryComponent(Complex parent, String parentType, String name, Bundle.BundleEntryComponent element, int index) { 1904 if (element == null) 1905 return; 1906 Complex t; 1907 if (Utilities.noString(parentType)) 1908 t = parent; 1909 else { 1910 t = parent.predicate("fhir:"+parentType+'.'+name); 1911 } 1912 composeBackboneElement(t, "entry", name, element, index); 1913 for (int i = 0; i < element.getLink().size(); i++) 1914 composeBundleBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i); 1915 if (element.hasFullUrlElement()) 1916 composeUri(t, "Bundle", "fullUrl", element.getFullUrlElement(), -1); 1917 if (element.hasResource()) 1918 composeResource(t, "Bundle", "resource", element.getResource(), -1); 1919 if (element.hasSearch()) 1920 composeBundleBundleEntrySearchComponent(t, "Bundle", "search", element.getSearch(), -1); 1921 if (element.hasRequest()) 1922 composeBundleBundleEntryRequestComponent(t, "Bundle", "request", element.getRequest(), -1); 1923 if (element.hasResponse()) 1924 composeBundleBundleEntryResponseComponent(t, "Bundle", "response", element.getResponse(), -1); 1925 } 1926 1927 protected void composeBundleBundleEntrySearchComponent(Complex parent, String parentType, String name, Bundle.BundleEntrySearchComponent element, int index) { 1928 if (element == null) 1929 return; 1930 Complex t; 1931 if (Utilities.noString(parentType)) 1932 t = parent; 1933 else { 1934 t = parent.predicate("fhir:"+parentType+'.'+name); 1935 } 1936 composeBackboneElement(t, "search", name, element, index); 1937 if (element.hasModeElement()) 1938 composeEnum(t, "Bundle", "mode", element.getModeElement(), -1); 1939 if (element.hasScoreElement()) 1940 composeDecimal(t, "Bundle", "score", element.getScoreElement(), -1); 1941 } 1942 1943 protected void composeBundleBundleEntryRequestComponent(Complex parent, String parentType, String name, Bundle.BundleEntryRequestComponent element, int index) { 1944 if (element == null) 1945 return; 1946 Complex t; 1947 if (Utilities.noString(parentType)) 1948 t = parent; 1949 else { 1950 t = parent.predicate("fhir:"+parentType+'.'+name); 1951 } 1952 composeBackboneElement(t, "request", name, element, index); 1953 if (element.hasMethodElement()) 1954 composeEnum(t, "Bundle", "method", element.getMethodElement(), -1); 1955 if (element.hasUrlElement()) 1956 composeUri(t, "Bundle", "url", element.getUrlElement(), -1); 1957 if (element.hasIfNoneMatchElement()) 1958 composeString(t, "Bundle", "ifNoneMatch", element.getIfNoneMatchElement(), -1); 1959 if (element.hasIfModifiedSinceElement()) 1960 composeInstant(t, "Bundle", "ifModifiedSince", element.getIfModifiedSinceElement(), -1); 1961 if (element.hasIfMatchElement()) 1962 composeString(t, "Bundle", "ifMatch", element.getIfMatchElement(), -1); 1963 if (element.hasIfNoneExistElement()) 1964 composeString(t, "Bundle", "ifNoneExist", element.getIfNoneExistElement(), -1); 1965 } 1966 1967 protected void composeBundleBundleEntryResponseComponent(Complex parent, String parentType, String name, Bundle.BundleEntryResponseComponent element, int index) { 1968 if (element == null) 1969 return; 1970 Complex t; 1971 if (Utilities.noString(parentType)) 1972 t = parent; 1973 else { 1974 t = parent.predicate("fhir:"+parentType+'.'+name); 1975 } 1976 composeBackboneElement(t, "response", name, element, index); 1977 if (element.hasStatusElement()) 1978 composeString(t, "Bundle", "status", element.getStatusElement(), -1); 1979 if (element.hasLocationElement()) 1980 composeUri(t, "Bundle", "location", element.getLocationElement(), -1); 1981 if (element.hasEtagElement()) 1982 composeString(t, "Bundle", "etag", element.getEtagElement(), -1); 1983 if (element.hasLastModifiedElement()) 1984 composeInstant(t, "Bundle", "lastModified", element.getLastModifiedElement(), -1); 1985 if (element.hasOutcome()) 1986 composeResource(t, "Bundle", "outcome", element.getOutcome(), -1); 1987 } 1988 1989 protected void composeCapabilityStatement(Complex parent, String parentType, String name, CapabilityStatement element, int index) { 1990 if (element == null) 1991 return; 1992 Complex t; 1993 if (Utilities.noString(parentType)) 1994 t = parent; 1995 else { 1996 t = parent.predicate("fhir:"+parentType+'.'+name); 1997 } 1998 composeDomainResource(t, "CapabilityStatement", name, element, index); 1999 if (element.hasUrlElement()) 2000 composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1); 2001 if (element.hasVersionElement()) 2002 composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1); 2003 if (element.hasNameElement()) 2004 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2005 if (element.hasTitleElement()) 2006 composeString(t, "CapabilityStatement", "title", element.getTitleElement(), -1); 2007 if (element.hasStatusElement()) 2008 composeEnum(t, "CapabilityStatement", "status", element.getStatusElement(), -1); 2009 if (element.hasExperimentalElement()) 2010 composeBoolean(t, "CapabilityStatement", "experimental", element.getExperimentalElement(), -1); 2011 if (element.hasDateElement()) 2012 composeDateTime(t, "CapabilityStatement", "date", element.getDateElement(), -1); 2013 if (element.hasPublisherElement()) 2014 composeString(t, "CapabilityStatement", "publisher", element.getPublisherElement(), -1); 2015 for (int i = 0; i < element.getContact().size(); i++) 2016 composeContactDetail(t, "CapabilityStatement", "contact", element.getContact().get(i), i); 2017 if (element.hasDescriptionElement()) 2018 composeMarkdown(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1); 2019 for (int i = 0; i < element.getUseContext().size(); i++) 2020 composeUsageContext(t, "CapabilityStatement", "useContext", element.getUseContext().get(i), i); 2021 for (int i = 0; i < element.getJurisdiction().size(); i++) 2022 composeCodeableConcept(t, "CapabilityStatement", "jurisdiction", element.getJurisdiction().get(i), i); 2023 if (element.hasPurposeElement()) 2024 composeMarkdown(t, "CapabilityStatement", "purpose", element.getPurposeElement(), -1); 2025 if (element.hasCopyrightElement()) 2026 composeMarkdown(t, "CapabilityStatement", "copyright", element.getCopyrightElement(), -1); 2027 if (element.hasKindElement()) 2028 composeEnum(t, "CapabilityStatement", "kind", element.getKindElement(), -1); 2029 for (int i = 0; i < element.getInstantiates().size(); i++) 2030 composeUri(t, "CapabilityStatement", "instantiates", element.getInstantiates().get(i), i); 2031 if (element.hasSoftware()) 2032 composeCapabilityStatementCapabilityStatementSoftwareComponent(t, "CapabilityStatement", "software", element.getSoftware(), -1); 2033 if (element.hasImplementation()) 2034 composeCapabilityStatementCapabilityStatementImplementationComponent(t, "CapabilityStatement", "implementation", element.getImplementation(), -1); 2035 if (element.hasFhirVersionElement()) 2036 composeId(t, "CapabilityStatement", "fhirVersion", element.getFhirVersionElement(), -1); 2037 if (element.hasAcceptUnknownElement()) 2038 composeEnum(t, "CapabilityStatement", "acceptUnknown", element.getAcceptUnknownElement(), -1); 2039 for (int i = 0; i < element.getFormat().size(); i++) 2040 composeCode(t, "CapabilityStatement", "format", element.getFormat().get(i), i); 2041 for (int i = 0; i < element.getPatchFormat().size(); i++) 2042 composeCode(t, "CapabilityStatement", "patchFormat", element.getPatchFormat().get(i), i); 2043 for (int i = 0; i < element.getImplementationGuide().size(); i++) 2044 composeUri(t, "CapabilityStatement", "implementationGuide", element.getImplementationGuide().get(i), i); 2045 for (int i = 0; i < element.getProfile().size(); i++) 2046 composeReference(t, "CapabilityStatement", "profile", element.getProfile().get(i), i); 2047 for (int i = 0; i < element.getRest().size(); i++) 2048 composeCapabilityStatementCapabilityStatementRestComponent(t, "CapabilityStatement", "rest", element.getRest().get(i), i); 2049 for (int i = 0; i < element.getMessaging().size(); i++) 2050 composeCapabilityStatementCapabilityStatementMessagingComponent(t, "CapabilityStatement", "messaging", element.getMessaging().get(i), i); 2051 for (int i = 0; i < element.getDocument().size(); i++) 2052 composeCapabilityStatementCapabilityStatementDocumentComponent(t, "CapabilityStatement", "document", element.getDocument().get(i), i); 2053 } 2054 2055 protected void composeCapabilityStatementCapabilityStatementSoftwareComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementSoftwareComponent element, int index) { 2056 if (element == null) 2057 return; 2058 Complex t; 2059 if (Utilities.noString(parentType)) 2060 t = parent; 2061 else { 2062 t = parent.predicate("fhir:"+parentType+'.'+name); 2063 } 2064 composeBackboneElement(t, "software", name, element, index); 2065 if (element.hasNameElement()) 2066 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2067 if (element.hasVersionElement()) 2068 composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1); 2069 if (element.hasReleaseDateElement()) 2070 composeDateTime(t, "CapabilityStatement", "releaseDate", element.getReleaseDateElement(), -1); 2071 } 2072 2073 protected void composeCapabilityStatementCapabilityStatementImplementationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementImplementationComponent element, int index) { 2074 if (element == null) 2075 return; 2076 Complex t; 2077 if (Utilities.noString(parentType)) 2078 t = parent; 2079 else { 2080 t = parent.predicate("fhir:"+parentType+'.'+name); 2081 } 2082 composeBackboneElement(t, "implementation", name, element, index); 2083 if (element.hasDescriptionElement()) 2084 composeString(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1); 2085 if (element.hasUrlElement()) 2086 composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1); 2087 } 2088 2089 protected void composeCapabilityStatementCapabilityStatementRestComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestComponent element, int index) { 2090 if (element == null) 2091 return; 2092 Complex t; 2093 if (Utilities.noString(parentType)) 2094 t = parent; 2095 else { 2096 t = parent.predicate("fhir:"+parentType+'.'+name); 2097 } 2098 composeBackboneElement(t, "rest", name, element, index); 2099 if (element.hasModeElement()) 2100 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2101 if (element.hasDocumentationElement()) 2102 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2103 if (element.hasSecurity()) 2104 composeCapabilityStatementCapabilityStatementRestSecurityComponent(t, "CapabilityStatement", "security", element.getSecurity(), -1); 2105 for (int i = 0; i < element.getResource().size(); i++) 2106 composeCapabilityStatementCapabilityStatementRestResourceComponent(t, "CapabilityStatement", "resource", element.getResource().get(i), i); 2107 for (int i = 0; i < element.getInteraction().size(); i++) 2108 composeCapabilityStatementSystemInteractionComponent(t, "CapabilityStatement", "interaction", element.getInteraction().get(i), i); 2109 for (int i = 0; i < element.getSearchParam().size(); i++) 2110 composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatement", "searchParam", element.getSearchParam().get(i), i); 2111 for (int i = 0; i < element.getOperation().size(); i++) 2112 composeCapabilityStatementCapabilityStatementRestOperationComponent(t, "CapabilityStatement", "operation", element.getOperation().get(i), i); 2113 for (int i = 0; i < element.getCompartment().size(); i++) 2114 composeUri(t, "CapabilityStatement", "compartment", element.getCompartment().get(i), i); 2115 } 2116 2117 protected void composeCapabilityStatementCapabilityStatementRestSecurityComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityComponent element, int index) { 2118 if (element == null) 2119 return; 2120 Complex t; 2121 if (Utilities.noString(parentType)) 2122 t = parent; 2123 else { 2124 t = parent.predicate("fhir:"+parentType+'.'+name); 2125 } 2126 composeBackboneElement(t, "security", name, element, index); 2127 if (element.hasCorsElement()) 2128 composeBoolean(t, "CapabilityStatement", "cors", element.getCorsElement(), -1); 2129 for (int i = 0; i < element.getService().size(); i++) 2130 composeCodeableConcept(t, "CapabilityStatement", "service", element.getService().get(i), i); 2131 if (element.hasDescriptionElement()) 2132 composeString(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1); 2133 for (int i = 0; i < element.getCertificate().size(); i++) 2134 composeCapabilityStatementCapabilityStatementRestSecurityCertificateComponent(t, "CapabilityStatement", "certificate", element.getCertificate().get(i), i); 2135 } 2136 2137 protected void composeCapabilityStatementCapabilityStatementRestSecurityCertificateComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityCertificateComponent 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, "certificate", name, element, index); 2147 if (element.hasTypeElement()) 2148 composeCode(t, "CapabilityStatement", "type", element.getTypeElement(), -1); 2149 if (element.hasBlobElement()) 2150 composeBase64Binary(t, "CapabilityStatement", "blob", element.getBlobElement(), -1); 2151 } 2152 2153 protected void composeCapabilityStatementCapabilityStatementRestResourceComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceComponent element, int index) { 2154 if (element == null) 2155 return; 2156 Complex t; 2157 if (Utilities.noString(parentType)) 2158 t = parent; 2159 else { 2160 t = parent.predicate("fhir:"+parentType+'.'+name); 2161 } 2162 composeBackboneElement(t, "resource", name, element, index); 2163 if (element.hasTypeElement()) 2164 composeCode(t, "CapabilityStatement", "type", element.getTypeElement(), -1); 2165 if (element.hasProfile()) 2166 composeReference(t, "CapabilityStatement", "profile", element.getProfile(), -1); 2167 if (element.hasDocumentationElement()) 2168 composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2169 for (int i = 0; i < element.getInteraction().size(); i++) 2170 composeCapabilityStatementResourceInteractionComponent(t, "CapabilityStatement", "interaction", element.getInteraction().get(i), i); 2171 if (element.hasVersioningElement()) 2172 composeEnum(t, "CapabilityStatement", "versioning", element.getVersioningElement(), -1); 2173 if (element.hasReadHistoryElement()) 2174 composeBoolean(t, "CapabilityStatement", "readHistory", element.getReadHistoryElement(), -1); 2175 if (element.hasUpdateCreateElement()) 2176 composeBoolean(t, "CapabilityStatement", "updateCreate", element.getUpdateCreateElement(), -1); 2177 if (element.hasConditionalCreateElement()) 2178 composeBoolean(t, "CapabilityStatement", "conditionalCreate", element.getConditionalCreateElement(), -1); 2179 if (element.hasConditionalReadElement()) 2180 composeEnum(t, "CapabilityStatement", "conditionalRead", element.getConditionalReadElement(), -1); 2181 if (element.hasConditionalUpdateElement()) 2182 composeBoolean(t, "CapabilityStatement", "conditionalUpdate", element.getConditionalUpdateElement(), -1); 2183 if (element.hasConditionalDeleteElement()) 2184 composeEnum(t, "CapabilityStatement", "conditionalDelete", element.getConditionalDeleteElement(), -1); 2185 for (int i = 0; i < element.getReferencePolicy().size(); i++) 2186 composeEnum(t, "CapabilityStatement", "referencePolicy", element.getReferencePolicy().get(i), i); 2187 for (int i = 0; i < element.getSearchInclude().size(); i++) 2188 composeString(t, "CapabilityStatement", "searchInclude", element.getSearchInclude().get(i), i); 2189 for (int i = 0; i < element.getSearchRevInclude().size(); i++) 2190 composeString(t, "CapabilityStatement", "searchRevInclude", element.getSearchRevInclude().get(i), i); 2191 for (int i = 0; i < element.getSearchParam().size(); i++) 2192 composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatement", "searchParam", element.getSearchParam().get(i), i); 2193 } 2194 2195 protected void composeCapabilityStatementResourceInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.ResourceInteractionComponent element, int index) { 2196 if (element == null) 2197 return; 2198 Complex t; 2199 if (Utilities.noString(parentType)) 2200 t = parent; 2201 else { 2202 t = parent.predicate("fhir:"+parentType+'.'+name); 2203 } 2204 composeBackboneElement(t, "interaction", name, element, index); 2205 if (element.hasCodeElement()) 2206 composeEnum(t, "CapabilityStatement", "code", element.getCodeElement(), -1); 2207 if (element.hasDocumentationElement()) 2208 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2209 } 2210 2211 protected void composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent element, int index) { 2212 if (element == null) 2213 return; 2214 Complex t; 2215 if (Utilities.noString(parentType)) 2216 t = parent; 2217 else { 2218 t = parent.predicate("fhir:"+parentType+'.'+name); 2219 } 2220 composeBackboneElement(t, "searchParam", name, element, index); 2221 if (element.hasNameElement()) 2222 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2223 if (element.hasDefinitionElement()) 2224 composeUri(t, "CapabilityStatement", "definition", element.getDefinitionElement(), -1); 2225 if (element.hasTypeElement()) 2226 composeEnum(t, "CapabilityStatement", "type", element.getTypeElement(), -1); 2227 if (element.hasDocumentationElement()) 2228 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2229 } 2230 2231 protected void composeCapabilityStatementSystemInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.SystemInteractionComponent 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, "interaction", name, element, index); 2241 if (element.hasCodeElement()) 2242 composeEnum(t, "CapabilityStatement", "code", element.getCodeElement(), -1); 2243 if (element.hasDocumentationElement()) 2244 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2245 } 2246 2247 protected void composeCapabilityStatementCapabilityStatementRestOperationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestOperationComponent element, int index) { 2248 if (element == null) 2249 return; 2250 Complex t; 2251 if (Utilities.noString(parentType)) 2252 t = parent; 2253 else { 2254 t = parent.predicate("fhir:"+parentType+'.'+name); 2255 } 2256 composeBackboneElement(t, "operation", name, element, index); 2257 if (element.hasNameElement()) 2258 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2259 if (element.hasDefinition()) 2260 composeReference(t, "CapabilityStatement", "definition", element.getDefinition(), -1); 2261 } 2262 2263 protected void composeCapabilityStatementCapabilityStatementMessagingComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingComponent element, int index) { 2264 if (element == null) 2265 return; 2266 Complex t; 2267 if (Utilities.noString(parentType)) 2268 t = parent; 2269 else { 2270 t = parent.predicate("fhir:"+parentType+'.'+name); 2271 } 2272 composeBackboneElement(t, "messaging", name, element, index); 2273 for (int i = 0; i < element.getEndpoint().size(); i++) 2274 composeCapabilityStatementCapabilityStatementMessagingEndpointComponent(t, "CapabilityStatement", "endpoint", element.getEndpoint().get(i), i); 2275 if (element.hasReliableCacheElement()) 2276 composeUnsignedInt(t, "CapabilityStatement", "reliableCache", element.getReliableCacheElement(), -1); 2277 if (element.hasDocumentationElement()) 2278 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2279 for (int i = 0; i < element.getSupportedMessage().size(); i++) 2280 composeCapabilityStatementCapabilityStatementMessagingSupportedMessageComponent(t, "CapabilityStatement", "supportedMessage", element.getSupportedMessage().get(i), i); 2281 for (int i = 0; i < element.getEvent().size(); i++) 2282 composeCapabilityStatementCapabilityStatementMessagingEventComponent(t, "CapabilityStatement", "event", element.getEvent().get(i), i); 2283 } 2284 2285 protected void composeCapabilityStatementCapabilityStatementMessagingEndpointComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEndpointComponent element, int index) { 2286 if (element == null) 2287 return; 2288 Complex t; 2289 if (Utilities.noString(parentType)) 2290 t = parent; 2291 else { 2292 t = parent.predicate("fhir:"+parentType+'.'+name); 2293 } 2294 composeBackboneElement(t, "endpoint", name, element, index); 2295 if (element.hasProtocol()) 2296 composeCoding(t, "CapabilityStatement", "protocol", element.getProtocol(), -1); 2297 if (element.hasAddressElement()) 2298 composeUri(t, "CapabilityStatement", "address", element.getAddressElement(), -1); 2299 } 2300 2301 protected void composeCapabilityStatementCapabilityStatementMessagingSupportedMessageComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent element, int index) { 2302 if (element == null) 2303 return; 2304 Complex t; 2305 if (Utilities.noString(parentType)) 2306 t = parent; 2307 else { 2308 t = parent.predicate("fhir:"+parentType+'.'+name); 2309 } 2310 composeBackboneElement(t, "supportedMessage", name, element, index); 2311 if (element.hasModeElement()) 2312 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2313 if (element.hasDefinition()) 2314 composeReference(t, "CapabilityStatement", "definition", element.getDefinition(), -1); 2315 } 2316 2317 protected void composeCapabilityStatementCapabilityStatementMessagingEventComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEventComponent element, int index) { 2318 if (element == null) 2319 return; 2320 Complex t; 2321 if (Utilities.noString(parentType)) 2322 t = parent; 2323 else { 2324 t = parent.predicate("fhir:"+parentType+'.'+name); 2325 } 2326 composeBackboneElement(t, "event", name, element, index); 2327 if (element.hasCode()) 2328 composeCoding(t, "CapabilityStatement", "code", element.getCode(), -1); 2329 if (element.hasCategoryElement()) 2330 composeEnum(t, "CapabilityStatement", "category", element.getCategoryElement(), -1); 2331 if (element.hasModeElement()) 2332 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2333 if (element.hasFocusElement()) 2334 composeCode(t, "CapabilityStatement", "focus", element.getFocusElement(), -1); 2335 if (element.hasRequest()) 2336 composeReference(t, "CapabilityStatement", "request", element.getRequest(), -1); 2337 if (element.hasResponse()) 2338 composeReference(t, "CapabilityStatement", "response", element.getResponse(), -1); 2339 if (element.hasDocumentationElement()) 2340 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2341 } 2342 2343 protected void composeCapabilityStatementCapabilityStatementDocumentComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementDocumentComponent element, int index) { 2344 if (element == null) 2345 return; 2346 Complex t; 2347 if (Utilities.noString(parentType)) 2348 t = parent; 2349 else { 2350 t = parent.predicate("fhir:"+parentType+'.'+name); 2351 } 2352 composeBackboneElement(t, "document", name, element, index); 2353 if (element.hasModeElement()) 2354 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2355 if (element.hasDocumentationElement()) 2356 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2357 if (element.hasProfile()) 2358 composeReference(t, "CapabilityStatement", "profile", element.getProfile(), -1); 2359 } 2360 2361 protected void composeCarePlan(Complex parent, String parentType, String name, CarePlan element, int index) { 2362 if (element == null) 2363 return; 2364 Complex t; 2365 if (Utilities.noString(parentType)) 2366 t = parent; 2367 else { 2368 t = parent.predicate("fhir:"+parentType+'.'+name); 2369 } 2370 composeDomainResource(t, "CarePlan", name, element, index); 2371 for (int i = 0; i < element.getIdentifier().size(); i++) 2372 composeIdentifier(t, "CarePlan", "identifier", element.getIdentifier().get(i), i); 2373 for (int i = 0; i < element.getDefinition().size(); i++) 2374 composeReference(t, "CarePlan", "definition", element.getDefinition().get(i), i); 2375 for (int i = 0; i < element.getBasedOn().size(); i++) 2376 composeReference(t, "CarePlan", "basedOn", element.getBasedOn().get(i), i); 2377 for (int i = 0; i < element.getReplaces().size(); i++) 2378 composeReference(t, "CarePlan", "replaces", element.getReplaces().get(i), i); 2379 for (int i = 0; i < element.getPartOf().size(); i++) 2380 composeReference(t, "CarePlan", "partOf", element.getPartOf().get(i), i); 2381 if (element.hasStatusElement()) 2382 composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1); 2383 if (element.hasIntentElement()) 2384 composeEnum(t, "CarePlan", "intent", element.getIntentElement(), -1); 2385 for (int i = 0; i < element.getCategory().size(); i++) 2386 composeCodeableConcept(t, "CarePlan", "category", element.getCategory().get(i), i); 2387 if (element.hasTitleElement()) 2388 composeString(t, "CarePlan", "title", element.getTitleElement(), -1); 2389 if (element.hasDescriptionElement()) 2390 composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1); 2391 if (element.hasSubject()) 2392 composeReference(t, "CarePlan", "subject", element.getSubject(), -1); 2393 if (element.hasContext()) 2394 composeReference(t, "CarePlan", "context", element.getContext(), -1); 2395 if (element.hasPeriod()) 2396 composePeriod(t, "CarePlan", "period", element.getPeriod(), -1); 2397 for (int i = 0; i < element.getAuthor().size(); i++) 2398 composeReference(t, "CarePlan", "author", element.getAuthor().get(i), i); 2399 for (int i = 0; i < element.getCareTeam().size(); i++) 2400 composeReference(t, "CarePlan", "careTeam", element.getCareTeam().get(i), i); 2401 for (int i = 0; i < element.getAddresses().size(); i++) 2402 composeReference(t, "CarePlan", "addresses", element.getAddresses().get(i), i); 2403 for (int i = 0; i < element.getSupportingInfo().size(); i++) 2404 composeReference(t, "CarePlan", "supportingInfo", element.getSupportingInfo().get(i), i); 2405 for (int i = 0; i < element.getGoal().size(); i++) 2406 composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i); 2407 for (int i = 0; i < element.getActivity().size(); i++) 2408 composeCarePlanCarePlanActivityComponent(t, "CarePlan", "activity", element.getActivity().get(i), i); 2409 for (int i = 0; i < element.getNote().size(); i++) 2410 composeAnnotation(t, "CarePlan", "note", element.getNote().get(i), i); 2411 } 2412 2413 protected void composeCarePlanCarePlanActivityComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityComponent element, int index) { 2414 if (element == null) 2415 return; 2416 Complex t; 2417 if (Utilities.noString(parentType)) 2418 t = parent; 2419 else { 2420 t = parent.predicate("fhir:"+parentType+'.'+name); 2421 } 2422 composeBackboneElement(t, "activity", name, element, index); 2423 for (int i = 0; i < element.getOutcomeCodeableConcept().size(); i++) 2424 composeCodeableConcept(t, "CarePlan", "outcomeCodeableConcept", element.getOutcomeCodeableConcept().get(i), i); 2425 for (int i = 0; i < element.getOutcomeReference().size(); i++) 2426 composeReference(t, "CarePlan", "outcomeReference", element.getOutcomeReference().get(i), i); 2427 for (int i = 0; i < element.getProgress().size(); i++) 2428 composeAnnotation(t, "CarePlan", "progress", element.getProgress().get(i), i); 2429 if (element.hasReference()) 2430 composeReference(t, "CarePlan", "reference", element.getReference(), -1); 2431 if (element.hasDetail()) 2432 composeCarePlanCarePlanActivityDetailComponent(t, "CarePlan", "detail", element.getDetail(), -1); 2433 } 2434 2435 protected void composeCarePlanCarePlanActivityDetailComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityDetailComponent element, int index) { 2436 if (element == null) 2437 return; 2438 Complex t; 2439 if (Utilities.noString(parentType)) 2440 t = parent; 2441 else { 2442 t = parent.predicate("fhir:"+parentType+'.'+name); 2443 } 2444 composeBackboneElement(t, "detail", name, element, index); 2445 if (element.hasCategory()) 2446 composeCodeableConcept(t, "CarePlan", "category", element.getCategory(), -1); 2447 if (element.hasDefinition()) 2448 composeReference(t, "CarePlan", "definition", element.getDefinition(), -1); 2449 if (element.hasCode()) 2450 composeCodeableConcept(t, "CarePlan", "code", element.getCode(), -1); 2451 for (int i = 0; i < element.getReasonCode().size(); i++) 2452 composeCodeableConcept(t, "CarePlan", "reasonCode", element.getReasonCode().get(i), i); 2453 for (int i = 0; i < element.getReasonReference().size(); i++) 2454 composeReference(t, "CarePlan", "reasonReference", element.getReasonReference().get(i), i); 2455 for (int i = 0; i < element.getGoal().size(); i++) 2456 composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i); 2457 if (element.hasStatusElement()) 2458 composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1); 2459 if (element.hasStatusReasonElement()) 2460 composeString(t, "CarePlan", "statusReason", element.getStatusReasonElement(), -1); 2461 if (element.hasProhibitedElement()) 2462 composeBoolean(t, "CarePlan", "prohibited", element.getProhibitedElement(), -1); 2463 if (element.hasScheduled()) 2464 composeType(t, "CarePlan", "scheduled", element.getScheduled(), -1); 2465 if (element.hasLocation()) 2466 composeReference(t, "CarePlan", "location", element.getLocation(), -1); 2467 for (int i = 0; i < element.getPerformer().size(); i++) 2468 composeReference(t, "CarePlan", "performer", element.getPerformer().get(i), i); 2469 if (element.hasProduct()) 2470 composeType(t, "CarePlan", "product", element.getProduct(), -1); 2471 if (element.hasDailyAmount()) 2472 composeQuantity(t, "CarePlan", "dailyAmount", element.getDailyAmount(), -1); 2473 if (element.hasQuantity()) 2474 composeQuantity(t, "CarePlan", "quantity", element.getQuantity(), -1); 2475 if (element.hasDescriptionElement()) 2476 composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1); 2477 } 2478 2479 protected void composeCareTeam(Complex parent, String parentType, String name, CareTeam element, int index) { 2480 if (element == null) 2481 return; 2482 Complex t; 2483 if (Utilities.noString(parentType)) 2484 t = parent; 2485 else { 2486 t = parent.predicate("fhir:"+parentType+'.'+name); 2487 } 2488 composeDomainResource(t, "CareTeam", name, element, index); 2489 for (int i = 0; i < element.getIdentifier().size(); i++) 2490 composeIdentifier(t, "CareTeam", "identifier", element.getIdentifier().get(i), i); 2491 if (element.hasStatusElement()) 2492 composeEnum(t, "CareTeam", "status", element.getStatusElement(), -1); 2493 for (int i = 0; i < element.getCategory().size(); i++) 2494 composeCodeableConcept(t, "CareTeam", "category", element.getCategory().get(i), i); 2495 if (element.hasNameElement()) 2496 composeString(t, "CareTeam", "name", element.getNameElement(), -1); 2497 if (element.hasSubject()) 2498 composeReference(t, "CareTeam", "subject", element.getSubject(), -1); 2499 if (element.hasContext()) 2500 composeReference(t, "CareTeam", "context", element.getContext(), -1); 2501 if (element.hasPeriod()) 2502 composePeriod(t, "CareTeam", "period", element.getPeriod(), -1); 2503 for (int i = 0; i < element.getParticipant().size(); i++) 2504 composeCareTeamCareTeamParticipantComponent(t, "CareTeam", "participant", element.getParticipant().get(i), i); 2505 for (int i = 0; i < element.getReasonCode().size(); i++) 2506 composeCodeableConcept(t, "CareTeam", "reasonCode", element.getReasonCode().get(i), i); 2507 for (int i = 0; i < element.getReasonReference().size(); i++) 2508 composeReference(t, "CareTeam", "reasonReference", element.getReasonReference().get(i), i); 2509 for (int i = 0; i < element.getManagingOrganization().size(); i++) 2510 composeReference(t, "CareTeam", "managingOrganization", element.getManagingOrganization().get(i), i); 2511 for (int i = 0; i < element.getNote().size(); i++) 2512 composeAnnotation(t, "CareTeam", "note", element.getNote().get(i), i); 2513 } 2514 2515 protected void composeCareTeamCareTeamParticipantComponent(Complex parent, String parentType, String name, CareTeam.CareTeamParticipantComponent element, int index) { 2516 if (element == null) 2517 return; 2518 Complex t; 2519 if (Utilities.noString(parentType)) 2520 t = parent; 2521 else { 2522 t = parent.predicate("fhir:"+parentType+'.'+name); 2523 } 2524 composeBackboneElement(t, "participant", name, element, index); 2525 if (element.hasRole()) 2526 composeCodeableConcept(t, "CareTeam", "role", element.getRole(), -1); 2527 if (element.hasMember()) 2528 composeReference(t, "CareTeam", "member", element.getMember(), -1); 2529 if (element.hasOnBehalfOf()) 2530 composeReference(t, "CareTeam", "onBehalfOf", element.getOnBehalfOf(), -1); 2531 if (element.hasPeriod()) 2532 composePeriod(t, "CareTeam", "period", element.getPeriod(), -1); 2533 } 2534 2535 protected void composeChargeItem(Complex parent, String parentType, String name, ChargeItem 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 composeDomainResource(t, "ChargeItem", name, element, index); 2545 if (element.hasIdentifier()) 2546 composeIdentifier(t, "ChargeItem", "identifier", element.getIdentifier(), -1); 2547 for (int i = 0; i < element.getDefinition().size(); i++) 2548 composeUri(t, "ChargeItem", "definition", element.getDefinition().get(i), i); 2549 if (element.hasStatusElement()) 2550 composeEnum(t, "ChargeItem", "status", element.getStatusElement(), -1); 2551 for (int i = 0; i < element.getPartOf().size(); i++) 2552 composeReference(t, "ChargeItem", "partOf", element.getPartOf().get(i), i); 2553 if (element.hasCode()) 2554 composeCodeableConcept(t, "ChargeItem", "code", element.getCode(), -1); 2555 if (element.hasSubject()) 2556 composeReference(t, "ChargeItem", "subject", element.getSubject(), -1); 2557 if (element.hasContext()) 2558 composeReference(t, "ChargeItem", "context", element.getContext(), -1); 2559 if (element.hasOccurrence()) 2560 composeType(t, "ChargeItem", "occurrence", element.getOccurrence(), -1); 2561 for (int i = 0; i < element.getParticipant().size(); i++) 2562 composeChargeItemChargeItemParticipantComponent(t, "ChargeItem", "participant", element.getParticipant().get(i), i); 2563 if (element.hasPerformingOrganization()) 2564 composeReference(t, "ChargeItem", "performingOrganization", element.getPerformingOrganization(), -1); 2565 if (element.hasRequestingOrganization()) 2566 composeReference(t, "ChargeItem", "requestingOrganization", element.getRequestingOrganization(), -1); 2567 if (element.hasQuantity()) 2568 composeQuantity(t, "ChargeItem", "quantity", element.getQuantity(), -1); 2569 for (int i = 0; i < element.getBodysite().size(); i++) 2570 composeCodeableConcept(t, "ChargeItem", "bodysite", element.getBodysite().get(i), i); 2571 if (element.hasFactorOverrideElement()) 2572 composeDecimal(t, "ChargeItem", "factorOverride", element.getFactorOverrideElement(), -1); 2573 if (element.hasPriceOverride()) 2574 composeMoney(t, "ChargeItem", "priceOverride", element.getPriceOverride(), -1); 2575 if (element.hasOverrideReasonElement()) 2576 composeString(t, "ChargeItem", "overrideReason", element.getOverrideReasonElement(), -1); 2577 if (element.hasEnterer()) 2578 composeReference(t, "ChargeItem", "enterer", element.getEnterer(), -1); 2579 if (element.hasEnteredDateElement()) 2580 composeDateTime(t, "ChargeItem", "enteredDate", element.getEnteredDateElement(), -1); 2581 for (int i = 0; i < element.getReason().size(); i++) 2582 composeCodeableConcept(t, "ChargeItem", "reason", element.getReason().get(i), i); 2583 for (int i = 0; i < element.getService().size(); i++) 2584 composeReference(t, "ChargeItem", "service", element.getService().get(i), i); 2585 for (int i = 0; i < element.getAccount().size(); i++) 2586 composeReference(t, "ChargeItem", "account", element.getAccount().get(i), i); 2587 for (int i = 0; i < element.getNote().size(); i++) 2588 composeAnnotation(t, "ChargeItem", "note", element.getNote().get(i), i); 2589 for (int i = 0; i < element.getSupportingInformation().size(); i++) 2590 composeReference(t, "ChargeItem", "supportingInformation", element.getSupportingInformation().get(i), i); 2591 } 2592 2593 protected void composeChargeItemChargeItemParticipantComponent(Complex parent, String parentType, String name, ChargeItem.ChargeItemParticipantComponent element, int index) { 2594 if (element == null) 2595 return; 2596 Complex t; 2597 if (Utilities.noString(parentType)) 2598 t = parent; 2599 else { 2600 t = parent.predicate("fhir:"+parentType+'.'+name); 2601 } 2602 composeBackboneElement(t, "participant", name, element, index); 2603 if (element.hasRole()) 2604 composeCodeableConcept(t, "ChargeItem", "role", element.getRole(), -1); 2605 if (element.hasActor()) 2606 composeReference(t, "ChargeItem", "actor", element.getActor(), -1); 2607 } 2608 2609 protected void composeClaim(Complex parent, String parentType, String name, Claim element, int index) { 2610 if (element == null) 2611 return; 2612 Complex t; 2613 if (Utilities.noString(parentType)) 2614 t = parent; 2615 else { 2616 t = parent.predicate("fhir:"+parentType+'.'+name); 2617 } 2618 composeDomainResource(t, "Claim", name, element, index); 2619 for (int i = 0; i < element.getIdentifier().size(); i++) 2620 composeIdentifier(t, "Claim", "identifier", element.getIdentifier().get(i), i); 2621 if (element.hasStatusElement()) 2622 composeEnum(t, "Claim", "status", element.getStatusElement(), -1); 2623 if (element.hasType()) 2624 composeCodeableConcept(t, "Claim", "type", element.getType(), -1); 2625 for (int i = 0; i < element.getSubType().size(); i++) 2626 composeCodeableConcept(t, "Claim", "subType", element.getSubType().get(i), i); 2627 if (element.hasUseElement()) 2628 composeEnum(t, "Claim", "use", element.getUseElement(), -1); 2629 if (element.hasPatient()) 2630 composeReference(t, "Claim", "patient", element.getPatient(), -1); 2631 if (element.hasBillablePeriod()) 2632 composePeriod(t, "Claim", "billablePeriod", element.getBillablePeriod(), -1); 2633 if (element.hasCreatedElement()) 2634 composeDateTime(t, "Claim", "created", element.getCreatedElement(), -1); 2635 if (element.hasEnterer()) 2636 composeReference(t, "Claim", "enterer", element.getEnterer(), -1); 2637 if (element.hasInsurer()) 2638 composeReference(t, "Claim", "insurer", element.getInsurer(), -1); 2639 if (element.hasProvider()) 2640 composeReference(t, "Claim", "provider", element.getProvider(), -1); 2641 if (element.hasOrganization()) 2642 composeReference(t, "Claim", "organization", element.getOrganization(), -1); 2643 if (element.hasPriority()) 2644 composeCodeableConcept(t, "Claim", "priority", element.getPriority(), -1); 2645 if (element.hasFundsReserve()) 2646 composeCodeableConcept(t, "Claim", "fundsReserve", element.getFundsReserve(), -1); 2647 for (int i = 0; i < element.getRelated().size(); i++) 2648 composeClaimRelatedClaimComponent(t, "Claim", "related", element.getRelated().get(i), i); 2649 if (element.hasPrescription()) 2650 composeReference(t, "Claim", "prescription", element.getPrescription(), -1); 2651 if (element.hasOriginalPrescription()) 2652 composeReference(t, "Claim", "originalPrescription", element.getOriginalPrescription(), -1); 2653 if (element.hasPayee()) 2654 composeClaimPayeeComponent(t, "Claim", "payee", element.getPayee(), -1); 2655 if (element.hasReferral()) 2656 composeReference(t, "Claim", "referral", element.getReferral(), -1); 2657 if (element.hasFacility()) 2658 composeReference(t, "Claim", "facility", element.getFacility(), -1); 2659 for (int i = 0; i < element.getCareTeam().size(); i++) 2660 composeClaimCareTeamComponent(t, "Claim", "careTeam", element.getCareTeam().get(i), i); 2661 for (int i = 0; i < element.getInformation().size(); i++) 2662 composeClaimSpecialConditionComponent(t, "Claim", "information", element.getInformation().get(i), i); 2663 for (int i = 0; i < element.getDiagnosis().size(); i++) 2664 composeClaimDiagnosisComponent(t, "Claim", "diagnosis", element.getDiagnosis().get(i), i); 2665 for (int i = 0; i < element.getProcedure().size(); i++) 2666 composeClaimProcedureComponent(t, "Claim", "procedure", element.getProcedure().get(i), i); 2667 for (int i = 0; i < element.getInsurance().size(); i++) 2668 composeClaimInsuranceComponent(t, "Claim", "insurance", element.getInsurance().get(i), i); 2669 if (element.hasAccident()) 2670 composeClaimAccidentComponent(t, "Claim", "accident", element.getAccident(), -1); 2671 if (element.hasEmploymentImpacted()) 2672 composePeriod(t, "Claim", "employmentImpacted", element.getEmploymentImpacted(), -1); 2673 if (element.hasHospitalization()) 2674 composePeriod(t, "Claim", "hospitalization", element.getHospitalization(), -1); 2675 for (int i = 0; i < element.getItem().size(); i++) 2676 composeClaimItemComponent(t, "Claim", "item", element.getItem().get(i), i); 2677 if (element.hasTotal()) 2678 composeMoney(t, "Claim", "total", element.getTotal(), -1); 2679 } 2680 2681 protected void composeClaimRelatedClaimComponent(Complex parent, String parentType, String name, Claim.RelatedClaimComponent element, int index) { 2682 if (element == null) 2683 return; 2684 Complex t; 2685 if (Utilities.noString(parentType)) 2686 t = parent; 2687 else { 2688 t = parent.predicate("fhir:"+parentType+'.'+name); 2689 } 2690 composeBackboneElement(t, "related", name, element, index); 2691 if (element.hasClaim()) 2692 composeReference(t, "Claim", "claim", element.getClaim(), -1); 2693 if (element.hasRelationship()) 2694 composeCodeableConcept(t, "Claim", "relationship", element.getRelationship(), -1); 2695 if (element.hasReference()) 2696 composeIdentifier(t, "Claim", "reference", element.getReference(), -1); 2697 } 2698 2699 protected void composeClaimPayeeComponent(Complex parent, String parentType, String name, Claim.PayeeComponent element, int index) { 2700 if (element == null) 2701 return; 2702 Complex t; 2703 if (Utilities.noString(parentType)) 2704 t = parent; 2705 else { 2706 t = parent.predicate("fhir:"+parentType+'.'+name); 2707 } 2708 composeBackboneElement(t, "payee", name, element, index); 2709 if (element.hasType()) 2710 composeCodeableConcept(t, "Claim", "type", element.getType(), -1); 2711 if (element.hasResourceType()) 2712 composeCoding(t, "Claim", "resourceType", element.getResourceType(), -1); 2713 if (element.hasParty()) 2714 composeReference(t, "Claim", "party", element.getParty(), -1); 2715 } 2716 2717 protected void composeClaimCareTeamComponent(Complex parent, String parentType, String name, Claim.CareTeamComponent element, int index) { 2718 if (element == null) 2719 return; 2720 Complex t; 2721 if (Utilities.noString(parentType)) 2722 t = parent; 2723 else { 2724 t = parent.predicate("fhir:"+parentType+'.'+name); 2725 } 2726 composeBackboneElement(t, "careTeam", name, element, index); 2727 if (element.hasSequenceElement()) 2728 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2729 if (element.hasProvider()) 2730 composeReference(t, "Claim", "provider", element.getProvider(), -1); 2731 if (element.hasResponsibleElement()) 2732 composeBoolean(t, "Claim", "responsible", element.getResponsibleElement(), -1); 2733 if (element.hasRole()) 2734 composeCodeableConcept(t, "Claim", "role", element.getRole(), -1); 2735 if (element.hasQualification()) 2736 composeCodeableConcept(t, "Claim", "qualification", element.getQualification(), -1); 2737 } 2738 2739 protected void composeClaimSpecialConditionComponent(Complex parent, String parentType, String name, Claim.SpecialConditionComponent element, int index) { 2740 if (element == null) 2741 return; 2742 Complex t; 2743 if (Utilities.noString(parentType)) 2744 t = parent; 2745 else { 2746 t = parent.predicate("fhir:"+parentType+'.'+name); 2747 } 2748 composeBackboneElement(t, "information", name, element, index); 2749 if (element.hasSequenceElement()) 2750 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2751 if (element.hasCategory()) 2752 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 2753 if (element.hasCode()) 2754 composeCodeableConcept(t, "Claim", "code", element.getCode(), -1); 2755 if (element.hasTiming()) 2756 composeType(t, "Claim", "timing", element.getTiming(), -1); 2757 if (element.hasValue()) 2758 composeType(t, "Claim", "value", element.getValue(), -1); 2759 if (element.hasReason()) 2760 composeCodeableConcept(t, "Claim", "reason", element.getReason(), -1); 2761 } 2762 2763 protected void composeClaimDiagnosisComponent(Complex parent, String parentType, String name, Claim.DiagnosisComponent element, int index) { 2764 if (element == null) 2765 return; 2766 Complex t; 2767 if (Utilities.noString(parentType)) 2768 t = parent; 2769 else { 2770 t = parent.predicate("fhir:"+parentType+'.'+name); 2771 } 2772 composeBackboneElement(t, "diagnosis", name, element, index); 2773 if (element.hasSequenceElement()) 2774 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2775 if (element.hasDiagnosis()) 2776 composeType(t, "Claim", "diagnosis", element.getDiagnosis(), -1); 2777 for (int i = 0; i < element.getType().size(); i++) 2778 composeCodeableConcept(t, "Claim", "type", element.getType().get(i), i); 2779 if (element.hasPackageCode()) 2780 composeCodeableConcept(t, "Claim", "packageCode", element.getPackageCode(), -1); 2781 } 2782 2783 protected void composeClaimProcedureComponent(Complex parent, String parentType, String name, Claim.ProcedureComponent 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, "procedure", name, element, index); 2793 if (element.hasSequenceElement()) 2794 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2795 if (element.hasDateElement()) 2796 composeDateTime(t, "Claim", "date", element.getDateElement(), -1); 2797 if (element.hasProcedure()) 2798 composeType(t, "Claim", "procedure", element.getProcedure(), -1); 2799 } 2800 2801 protected void composeClaimInsuranceComponent(Complex parent, String parentType, String name, Claim.InsuranceComponent element, int index) { 2802 if (element == null) 2803 return; 2804 Complex t; 2805 if (Utilities.noString(parentType)) 2806 t = parent; 2807 else { 2808 t = parent.predicate("fhir:"+parentType+'.'+name); 2809 } 2810 composeBackboneElement(t, "insurance", name, element, index); 2811 if (element.hasSequenceElement()) 2812 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2813 if (element.hasFocalElement()) 2814 composeBoolean(t, "Claim", "focal", element.getFocalElement(), -1); 2815 if (element.hasCoverage()) 2816 composeReference(t, "Claim", "coverage", element.getCoverage(), -1); 2817 if (element.hasBusinessArrangementElement()) 2818 composeString(t, "Claim", "businessArrangement", element.getBusinessArrangementElement(), -1); 2819 for (int i = 0; i < element.getPreAuthRef().size(); i++) 2820 composeString(t, "Claim", "preAuthRef", element.getPreAuthRef().get(i), i); 2821 if (element.hasClaimResponse()) 2822 composeReference(t, "Claim", "claimResponse", element.getClaimResponse(), -1); 2823 } 2824 2825 protected void composeClaimAccidentComponent(Complex parent, String parentType, String name, Claim.AccidentComponent element, int index) { 2826 if (element == null) 2827 return; 2828 Complex t; 2829 if (Utilities.noString(parentType)) 2830 t = parent; 2831 else { 2832 t = parent.predicate("fhir:"+parentType+'.'+name); 2833 } 2834 composeBackboneElement(t, "accident", name, element, index); 2835 if (element.hasDateElement()) 2836 composeDate(t, "Claim", "date", element.getDateElement(), -1); 2837 if (element.hasType()) 2838 composeCodeableConcept(t, "Claim", "type", element.getType(), -1); 2839 if (element.hasLocation()) 2840 composeType(t, "Claim", "location", element.getLocation(), -1); 2841 } 2842 2843 protected void composeClaimItemComponent(Complex parent, String parentType, String name, Claim.ItemComponent element, int index) { 2844 if (element == null) 2845 return; 2846 Complex t; 2847 if (Utilities.noString(parentType)) 2848 t = parent; 2849 else { 2850 t = parent.predicate("fhir:"+parentType+'.'+name); 2851 } 2852 composeBackboneElement(t, "item", name, element, index); 2853 if (element.hasSequenceElement()) 2854 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2855 for (int i = 0; i < element.getCareTeamLinkId().size(); i++) 2856 composePositiveInt(t, "Claim", "careTeamLinkId", element.getCareTeamLinkId().get(i), i); 2857 for (int i = 0; i < element.getDiagnosisLinkId().size(); i++) 2858 composePositiveInt(t, "Claim", "diagnosisLinkId", element.getDiagnosisLinkId().get(i), i); 2859 for (int i = 0; i < element.getProcedureLinkId().size(); i++) 2860 composePositiveInt(t, "Claim", "procedureLinkId", element.getProcedureLinkId().get(i), i); 2861 for (int i = 0; i < element.getInformationLinkId().size(); i++) 2862 composePositiveInt(t, "Claim", "informationLinkId", element.getInformationLinkId().get(i), i); 2863 if (element.hasRevenue()) 2864 composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1); 2865 if (element.hasCategory()) 2866 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 2867 if (element.hasService()) 2868 composeCodeableConcept(t, "Claim", "service", element.getService(), -1); 2869 for (int i = 0; i < element.getModifier().size(); i++) 2870 composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i); 2871 for (int i = 0; i < element.getProgramCode().size(); i++) 2872 composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i); 2873 if (element.hasServiced()) 2874 composeType(t, "Claim", "serviced", element.getServiced(), -1); 2875 if (element.hasLocation()) 2876 composeType(t, "Claim", "location", element.getLocation(), -1); 2877 if (element.hasQuantity()) 2878 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 2879 if (element.hasUnitPrice()) 2880 composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 2881 if (element.hasFactorElement()) 2882 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 2883 if (element.hasNet()) 2884 composeMoney(t, "Claim", "net", element.getNet(), -1); 2885 for (int i = 0; i < element.getUdi().size(); i++) 2886 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 2887 if (element.hasBodySite()) 2888 composeCodeableConcept(t, "Claim", "bodySite", element.getBodySite(), -1); 2889 for (int i = 0; i < element.getSubSite().size(); i++) 2890 composeCodeableConcept(t, "Claim", "subSite", element.getSubSite().get(i), i); 2891 for (int i = 0; i < element.getEncounter().size(); i++) 2892 composeReference(t, "Claim", "encounter", element.getEncounter().get(i), i); 2893 for (int i = 0; i < element.getDetail().size(); i++) 2894 composeClaimDetailComponent(t, "Claim", "detail", element.getDetail().get(i), i); 2895 } 2896 2897 protected void composeClaimDetailComponent(Complex parent, String parentType, String name, Claim.DetailComponent element, int index) { 2898 if (element == null) 2899 return; 2900 Complex t; 2901 if (Utilities.noString(parentType)) 2902 t = parent; 2903 else { 2904 t = parent.predicate("fhir:"+parentType+'.'+name); 2905 } 2906 composeBackboneElement(t, "detail", name, element, index); 2907 if (element.hasSequenceElement()) 2908 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2909 if (element.hasRevenue()) 2910 composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1); 2911 if (element.hasCategory()) 2912 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 2913 if (element.hasService()) 2914 composeCodeableConcept(t, "Claim", "service", element.getService(), -1); 2915 for (int i = 0; i < element.getModifier().size(); i++) 2916 composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i); 2917 for (int i = 0; i < element.getProgramCode().size(); i++) 2918 composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i); 2919 if (element.hasQuantity()) 2920 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 2921 if (element.hasUnitPrice()) 2922 composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 2923 if (element.hasFactorElement()) 2924 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 2925 if (element.hasNet()) 2926 composeMoney(t, "Claim", "net", element.getNet(), -1); 2927 for (int i = 0; i < element.getUdi().size(); i++) 2928 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 2929 for (int i = 0; i < element.getSubDetail().size(); i++) 2930 composeClaimSubDetailComponent(t, "Claim", "subDetail", element.getSubDetail().get(i), i); 2931 } 2932 2933 protected void composeClaimSubDetailComponent(Complex parent, String parentType, String name, Claim.SubDetailComponent element, int index) { 2934 if (element == null) 2935 return; 2936 Complex t; 2937 if (Utilities.noString(parentType)) 2938 t = parent; 2939 else { 2940 t = parent.predicate("fhir:"+parentType+'.'+name); 2941 } 2942 composeBackboneElement(t, "subDetail", name, element, index); 2943 if (element.hasSequenceElement()) 2944 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2945 if (element.hasRevenue()) 2946 composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1); 2947 if (element.hasCategory()) 2948 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 2949 if (element.hasService()) 2950 composeCodeableConcept(t, "Claim", "service", element.getService(), -1); 2951 for (int i = 0; i < element.getModifier().size(); i++) 2952 composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i); 2953 for (int i = 0; i < element.getProgramCode().size(); i++) 2954 composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i); 2955 if (element.hasQuantity()) 2956 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 2957 if (element.hasUnitPrice()) 2958 composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 2959 if (element.hasFactorElement()) 2960 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 2961 if (element.hasNet()) 2962 composeMoney(t, "Claim", "net", element.getNet(), -1); 2963 for (int i = 0; i < element.getUdi().size(); i++) 2964 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 2965 } 2966 2967 protected void composeClaimResponse(Complex parent, String parentType, String name, ClaimResponse element, int index) { 2968 if (element == null) 2969 return; 2970 Complex t; 2971 if (Utilities.noString(parentType)) 2972 t = parent; 2973 else { 2974 t = parent.predicate("fhir:"+parentType+'.'+name); 2975 } 2976 composeDomainResource(t, "ClaimResponse", name, element, index); 2977 for (int i = 0; i < element.getIdentifier().size(); i++) 2978 composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier().get(i), i); 2979 if (element.hasStatusElement()) 2980 composeEnum(t, "ClaimResponse", "status", element.getStatusElement(), -1); 2981 if (element.hasPatient()) 2982 composeReference(t, "ClaimResponse", "patient", element.getPatient(), -1); 2983 if (element.hasCreatedElement()) 2984 composeDateTime(t, "ClaimResponse", "created", element.getCreatedElement(), -1); 2985 if (element.hasInsurer()) 2986 composeReference(t, "ClaimResponse", "insurer", element.getInsurer(), -1); 2987 if (element.hasRequestProvider()) 2988 composeReference(t, "ClaimResponse", "requestProvider", element.getRequestProvider(), -1); 2989 if (element.hasRequestOrganization()) 2990 composeReference(t, "ClaimResponse", "requestOrganization", element.getRequestOrganization(), -1); 2991 if (element.hasRequest()) 2992 composeReference(t, "ClaimResponse", "request", element.getRequest(), -1); 2993 if (element.hasOutcome()) 2994 composeCodeableConcept(t, "ClaimResponse", "outcome", element.getOutcome(), -1); 2995 if (element.hasDispositionElement()) 2996 composeString(t, "ClaimResponse", "disposition", element.getDispositionElement(), -1); 2997 if (element.hasPayeeType()) 2998 composeCodeableConcept(t, "ClaimResponse", "payeeType", element.getPayeeType(), -1); 2999 for (int i = 0; i < element.getItem().size(); i++) 3000 composeClaimResponseItemComponent(t, "ClaimResponse", "item", element.getItem().get(i), i); 3001 for (int i = 0; i < element.getAddItem().size(); i++) 3002 composeClaimResponseAddedItemComponent(t, "ClaimResponse", "addItem", element.getAddItem().get(i), i); 3003 for (int i = 0; i < element.getError().size(); i++) 3004 composeClaimResponseErrorComponent(t, "ClaimResponse", "error", element.getError().get(i), i); 3005 if (element.hasTotalCost()) 3006 composeMoney(t, "ClaimResponse", "totalCost", element.getTotalCost(), -1); 3007 if (element.hasUnallocDeductable()) 3008 composeMoney(t, "ClaimResponse", "unallocDeductable", element.getUnallocDeductable(), -1); 3009 if (element.hasTotalBenefit()) 3010 composeMoney(t, "ClaimResponse", "totalBenefit", element.getTotalBenefit(), -1); 3011 if (element.hasPayment()) 3012 composeClaimResponsePaymentComponent(t, "ClaimResponse", "payment", element.getPayment(), -1); 3013 if (element.hasReserved()) 3014 composeCoding(t, "ClaimResponse", "reserved", element.getReserved(), -1); 3015 if (element.hasForm()) 3016 composeCodeableConcept(t, "ClaimResponse", "form", element.getForm(), -1); 3017 for (int i = 0; i < element.getProcessNote().size(); i++) 3018 composeClaimResponseNoteComponent(t, "ClaimResponse", "processNote", element.getProcessNote().get(i), i); 3019 for (int i = 0; i < element.getCommunicationRequest().size(); i++) 3020 composeReference(t, "ClaimResponse", "communicationRequest", element.getCommunicationRequest().get(i), i); 3021 for (int i = 0; i < element.getInsurance().size(); i++) 3022 composeClaimResponseInsuranceComponent(t, "ClaimResponse", "insurance", element.getInsurance().get(i), i); 3023 } 3024 3025 protected void composeClaimResponseItemComponent(Complex parent, String parentType, String name, ClaimResponse.ItemComponent element, int index) { 3026 if (element == null) 3027 return; 3028 Complex t; 3029 if (Utilities.noString(parentType)) 3030 t = parent; 3031 else { 3032 t = parent.predicate("fhir:"+parentType+'.'+name); 3033 } 3034 composeBackboneElement(t, "item", name, element, index); 3035 if (element.hasSequenceLinkIdElement()) 3036 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 3037 for (int i = 0; i < element.getNoteNumber().size(); i++) 3038 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3039 for (int i = 0; i < element.getAdjudication().size(); i++) 3040 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3041 for (int i = 0; i < element.getDetail().size(); i++) 3042 composeClaimResponseItemDetailComponent(t, "ClaimResponse", "detail", element.getDetail().get(i), i); 3043 } 3044 3045 protected void composeClaimResponseAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.AdjudicationComponent 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, "adjudication", name, element, index); 3055 if (element.hasCategory()) 3056 composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1); 3057 if (element.hasReason()) 3058 composeCodeableConcept(t, "ClaimResponse", "reason", element.getReason(), -1); 3059 if (element.hasAmount()) 3060 composeMoney(t, "ClaimResponse", "amount", element.getAmount(), -1); 3061 if (element.hasValueElement()) 3062 composeDecimal(t, "ClaimResponse", "value", element.getValueElement(), -1); 3063 } 3064 3065 protected void composeClaimResponseItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.ItemDetailComponent 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, "detail", name, element, index); 3075 if (element.hasSequenceLinkIdElement()) 3076 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 3077 for (int i = 0; i < element.getNoteNumber().size(); i++) 3078 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3079 for (int i = 0; i < element.getAdjudication().size(); i++) 3080 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3081 for (int i = 0; i < element.getSubDetail().size(); i++) 3082 composeClaimResponseSubDetailComponent(t, "ClaimResponse", "subDetail", element.getSubDetail().get(i), i); 3083 } 3084 3085 protected void composeClaimResponseSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.SubDetailComponent 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, "subDetail", 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 } 3102 3103 protected void composeClaimResponseAddedItemComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemComponent element, int index) { 3104 if (element == null) 3105 return; 3106 Complex t; 3107 if (Utilities.noString(parentType)) 3108 t = parent; 3109 else { 3110 t = parent.predicate("fhir:"+parentType+'.'+name); 3111 } 3112 composeBackboneElement(t, "addItem", name, element, index); 3113 for (int i = 0; i < element.getSequenceLinkId().size(); i++) 3114 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkId().get(i), i); 3115 if (element.hasRevenue()) 3116 composeCodeableConcept(t, "ClaimResponse", "revenue", element.getRevenue(), -1); 3117 if (element.hasCategory()) 3118 composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1); 3119 if (element.hasService()) 3120 composeCodeableConcept(t, "ClaimResponse", "service", element.getService(), -1); 3121 for (int i = 0; i < element.getModifier().size(); i++) 3122 composeCodeableConcept(t, "ClaimResponse", "modifier", element.getModifier().get(i), i); 3123 if (element.hasFee()) 3124 composeMoney(t, "ClaimResponse", "fee", element.getFee(), -1); 3125 for (int i = 0; i < element.getNoteNumber().size(); i++) 3126 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3127 for (int i = 0; i < element.getAdjudication().size(); i++) 3128 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3129 for (int i = 0; i < element.getDetail().size(); i++) 3130 composeClaimResponseAddedItemsDetailComponent(t, "ClaimResponse", "detail", element.getDetail().get(i), i); 3131 } 3132 3133 protected void composeClaimResponseAddedItemsDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemsDetailComponent element, int index) { 3134 if (element == null) 3135 return; 3136 Complex t; 3137 if (Utilities.noString(parentType)) 3138 t = parent; 3139 else { 3140 t = parent.predicate("fhir:"+parentType+'.'+name); 3141 } 3142 composeBackboneElement(t, "detail", name, element, index); 3143 if (element.hasRevenue()) 3144 composeCodeableConcept(t, "ClaimResponse", "revenue", element.getRevenue(), -1); 3145 if (element.hasCategory()) 3146 composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1); 3147 if (element.hasService()) 3148 composeCodeableConcept(t, "ClaimResponse", "service", element.getService(), -1); 3149 for (int i = 0; i < element.getModifier().size(); i++) 3150 composeCodeableConcept(t, "ClaimResponse", "modifier", element.getModifier().get(i), i); 3151 if (element.hasFee()) 3152 composeMoney(t, "ClaimResponse", "fee", element.getFee(), -1); 3153 for (int i = 0; i < element.getNoteNumber().size(); i++) 3154 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3155 for (int i = 0; i < element.getAdjudication().size(); i++) 3156 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3157 } 3158 3159 protected void composeClaimResponseErrorComponent(Complex parent, String parentType, String name, ClaimResponse.ErrorComponent element, int index) { 3160 if (element == null) 3161 return; 3162 Complex t; 3163 if (Utilities.noString(parentType)) 3164 t = parent; 3165 else { 3166 t = parent.predicate("fhir:"+parentType+'.'+name); 3167 } 3168 composeBackboneElement(t, "error", name, element, index); 3169 if (element.hasSequenceLinkIdElement()) 3170 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 3171 if (element.hasDetailSequenceLinkIdElement()) 3172 composePositiveInt(t, "ClaimResponse", "detailSequenceLinkId", element.getDetailSequenceLinkIdElement(), -1); 3173 if (element.hasSubdetailSequenceLinkIdElement()) 3174 composePositiveInt(t, "ClaimResponse", "subdetailSequenceLinkId", element.getSubdetailSequenceLinkIdElement(), -1); 3175 if (element.hasCode()) 3176 composeCodeableConcept(t, "ClaimResponse", "code", element.getCode(), -1); 3177 } 3178 3179 protected void composeClaimResponsePaymentComponent(Complex parent, String parentType, String name, ClaimResponse.PaymentComponent 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, "payment", name, element, index); 3189 if (element.hasType()) 3190 composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1); 3191 if (element.hasAdjustment()) 3192 composeMoney(t, "ClaimResponse", "adjustment", element.getAdjustment(), -1); 3193 if (element.hasAdjustmentReason()) 3194 composeCodeableConcept(t, "ClaimResponse", "adjustmentReason", element.getAdjustmentReason(), -1); 3195 if (element.hasDateElement()) 3196 composeDate(t, "ClaimResponse", "date", element.getDateElement(), -1); 3197 if (element.hasAmount()) 3198 composeMoney(t, "ClaimResponse", "amount", element.getAmount(), -1); 3199 if (element.hasIdentifier()) 3200 composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier(), -1); 3201 } 3202 3203 protected void composeClaimResponseNoteComponent(Complex parent, String parentType, String name, ClaimResponse.NoteComponent element, int index) { 3204 if (element == null) 3205 return; 3206 Complex t; 3207 if (Utilities.noString(parentType)) 3208 t = parent; 3209 else { 3210 t = parent.predicate("fhir:"+parentType+'.'+name); 3211 } 3212 composeBackboneElement(t, "processNote", name, element, index); 3213 if (element.hasNumberElement()) 3214 composePositiveInt(t, "ClaimResponse", "number", element.getNumberElement(), -1); 3215 if (element.hasType()) 3216 composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1); 3217 if (element.hasTextElement()) 3218 composeString(t, "ClaimResponse", "text", element.getTextElement(), -1); 3219 if (element.hasLanguage()) 3220 composeCodeableConcept(t, "ClaimResponse", "language", element.getLanguage(), -1); 3221 } 3222 3223 protected void composeClaimResponseInsuranceComponent(Complex parent, String parentType, String name, ClaimResponse.InsuranceComponent 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, "insurance", name, element, index); 3233 if (element.hasSequenceElement()) 3234 composePositiveInt(t, "ClaimResponse", "sequence", element.getSequenceElement(), -1); 3235 if (element.hasFocalElement()) 3236 composeBoolean(t, "ClaimResponse", "focal", element.getFocalElement(), -1); 3237 if (element.hasCoverage()) 3238 composeReference(t, "ClaimResponse", "coverage", element.getCoverage(), -1); 3239 if (element.hasBusinessArrangementElement()) 3240 composeString(t, "ClaimResponse", "businessArrangement", element.getBusinessArrangementElement(), -1); 3241 for (int i = 0; i < element.getPreAuthRef().size(); i++) 3242 composeString(t, "ClaimResponse", "preAuthRef", element.getPreAuthRef().get(i), i); 3243 if (element.hasClaimResponse()) 3244 composeReference(t, "ClaimResponse", "claimResponse", element.getClaimResponse(), -1); 3245 } 3246 3247 protected void composeClinicalImpression(Complex parent, String parentType, String name, ClinicalImpression element, int index) { 3248 if (element == null) 3249 return; 3250 Complex t; 3251 if (Utilities.noString(parentType)) 3252 t = parent; 3253 else { 3254 t = parent.predicate("fhir:"+parentType+'.'+name); 3255 } 3256 composeDomainResource(t, "ClinicalImpression", name, element, index); 3257 for (int i = 0; i < element.getIdentifier().size(); i++) 3258 composeIdentifier(t, "ClinicalImpression", "identifier", element.getIdentifier().get(i), i); 3259 if (element.hasStatusElement()) 3260 composeEnum(t, "ClinicalImpression", "status", element.getStatusElement(), -1); 3261 if (element.hasCode()) 3262 composeCodeableConcept(t, "ClinicalImpression", "code", element.getCode(), -1); 3263 if (element.hasDescriptionElement()) 3264 composeString(t, "ClinicalImpression", "description", element.getDescriptionElement(), -1); 3265 if (element.hasSubject()) 3266 composeReference(t, "ClinicalImpression", "subject", element.getSubject(), -1); 3267 if (element.hasContext()) 3268 composeReference(t, "ClinicalImpression", "context", element.getContext(), -1); 3269 if (element.hasEffective()) 3270 composeType(t, "ClinicalImpression", "effective", element.getEffective(), -1); 3271 if (element.hasDateElement()) 3272 composeDateTime(t, "ClinicalImpression", "date", element.getDateElement(), -1); 3273 if (element.hasAssessor()) 3274 composeReference(t, "ClinicalImpression", "assessor", element.getAssessor(), -1); 3275 if (element.hasPrevious()) 3276 composeReference(t, "ClinicalImpression", "previous", element.getPrevious(), -1); 3277 for (int i = 0; i < element.getProblem().size(); i++) 3278 composeReference(t, "ClinicalImpression", "problem", element.getProblem().get(i), i); 3279 for (int i = 0; i < element.getInvestigation().size(); i++) 3280 composeClinicalImpressionClinicalImpressionInvestigationComponent(t, "ClinicalImpression", "investigation", element.getInvestigation().get(i), i); 3281 for (int i = 0; i < element.getProtocol().size(); i++) 3282 composeUri(t, "ClinicalImpression", "protocol", element.getProtocol().get(i), i); 3283 if (element.hasSummaryElement()) 3284 composeString(t, "ClinicalImpression", "summary", element.getSummaryElement(), -1); 3285 for (int i = 0; i < element.getFinding().size(); i++) 3286 composeClinicalImpressionClinicalImpressionFindingComponent(t, "ClinicalImpression", "finding", element.getFinding().get(i), i); 3287 for (int i = 0; i < element.getPrognosisCodeableConcept().size(); i++) 3288 composeCodeableConcept(t, "ClinicalImpression", "prognosisCodeableConcept", element.getPrognosisCodeableConcept().get(i), i); 3289 for (int i = 0; i < element.getPrognosisReference().size(); i++) 3290 composeReference(t, "ClinicalImpression", "prognosisReference", element.getPrognosisReference().get(i), i); 3291 for (int i = 0; i < element.getAction().size(); i++) 3292 composeReference(t, "ClinicalImpression", "action", element.getAction().get(i), i); 3293 for (int i = 0; i < element.getNote().size(); i++) 3294 composeAnnotation(t, "ClinicalImpression", "note", element.getNote().get(i), i); 3295 } 3296 3297 protected void composeClinicalImpressionClinicalImpressionInvestigationComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionInvestigationComponent element, int index) { 3298 if (element == null) 3299 return; 3300 Complex t; 3301 if (Utilities.noString(parentType)) 3302 t = parent; 3303 else { 3304 t = parent.predicate("fhir:"+parentType+'.'+name); 3305 } 3306 composeBackboneElement(t, "investigation", name, element, index); 3307 if (element.hasCode()) 3308 composeCodeableConcept(t, "ClinicalImpression", "code", element.getCode(), -1); 3309 for (int i = 0; i < element.getItem().size(); i++) 3310 composeReference(t, "ClinicalImpression", "item", element.getItem().get(i), i); 3311 } 3312 3313 protected void composeClinicalImpressionClinicalImpressionFindingComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionFindingComponent element, int index) { 3314 if (element == null) 3315 return; 3316 Complex t; 3317 if (Utilities.noString(parentType)) 3318 t = parent; 3319 else { 3320 t = parent.predicate("fhir:"+parentType+'.'+name); 3321 } 3322 composeBackboneElement(t, "finding", name, element, index); 3323 if (element.hasItem()) 3324 composeType(t, "ClinicalImpression", "item", element.getItem(), -1); 3325 if (element.hasBasisElement()) 3326 composeString(t, "ClinicalImpression", "basis", element.getBasisElement(), -1); 3327 } 3328 3329 protected void composeCodeSystem(Complex parent, String parentType, String name, CodeSystem element, int index) { 3330 if (element == null) 3331 return; 3332 Complex t; 3333 if (Utilities.noString(parentType)) 3334 t = parent; 3335 else { 3336 t = parent.predicate("fhir:"+parentType+'.'+name); 3337 } 3338 composeDomainResource(t, "CodeSystem", name, element, index); 3339 if (element.hasUrlElement()) 3340 composeUri(t, "CodeSystem", "url", element.getUrlElement(), -1); 3341 if (element.hasIdentifier()) 3342 composeIdentifier(t, "CodeSystem", "identifier", element.getIdentifier(), -1); 3343 if (element.hasVersionElement()) 3344 composeString(t, "CodeSystem", "version", element.getVersionElement(), -1); 3345 if (element.hasNameElement()) 3346 composeString(t, "CodeSystem", "name", element.getNameElement(), -1); 3347 if (element.hasTitleElement()) 3348 composeString(t, "CodeSystem", "title", element.getTitleElement(), -1); 3349 if (element.hasStatusElement()) 3350 composeEnum(t, "CodeSystem", "status", element.getStatusElement(), -1); 3351 if (element.hasExperimentalElement()) 3352 composeBoolean(t, "CodeSystem", "experimental", element.getExperimentalElement(), -1); 3353 if (element.hasDateElement()) 3354 composeDateTime(t, "CodeSystem", "date", element.getDateElement(), -1); 3355 if (element.hasPublisherElement()) 3356 composeString(t, "CodeSystem", "publisher", element.getPublisherElement(), -1); 3357 for (int i = 0; i < element.getContact().size(); i++) 3358 composeContactDetail(t, "CodeSystem", "contact", element.getContact().get(i), i); 3359 if (element.hasDescriptionElement()) 3360 composeMarkdown(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 3361 for (int i = 0; i < element.getUseContext().size(); i++) 3362 composeUsageContext(t, "CodeSystem", "useContext", element.getUseContext().get(i), i); 3363 for (int i = 0; i < element.getJurisdiction().size(); i++) 3364 composeCodeableConcept(t, "CodeSystem", "jurisdiction", element.getJurisdiction().get(i), i); 3365 if (element.hasPurposeElement()) 3366 composeMarkdown(t, "CodeSystem", "purpose", element.getPurposeElement(), -1); 3367 if (element.hasCopyrightElement()) 3368 composeMarkdown(t, "CodeSystem", "copyright", element.getCopyrightElement(), -1); 3369 if (element.hasCaseSensitiveElement()) 3370 composeBoolean(t, "CodeSystem", "caseSensitive", element.getCaseSensitiveElement(), -1); 3371 if (element.hasValueSetElement()) 3372 composeUri(t, "CodeSystem", "valueSet", element.getValueSetElement(), -1); 3373 if (element.hasHierarchyMeaningElement()) 3374 composeEnum(t, "CodeSystem", "hierarchyMeaning", element.getHierarchyMeaningElement(), -1); 3375 if (element.hasCompositionalElement()) 3376 composeBoolean(t, "CodeSystem", "compositional", element.getCompositionalElement(), -1); 3377 if (element.hasVersionNeededElement()) 3378 composeBoolean(t, "CodeSystem", "versionNeeded", element.getVersionNeededElement(), -1); 3379 if (element.hasContentElement()) 3380 composeEnum(t, "CodeSystem", "content", element.getContentElement(), -1); 3381 if (element.hasCountElement()) 3382 composeUnsignedInt(t, "CodeSystem", "count", element.getCountElement(), -1); 3383 for (int i = 0; i < element.getFilter().size(); i++) 3384 composeCodeSystemCodeSystemFilterComponent(t, "CodeSystem", "filter", element.getFilter().get(i), i); 3385 for (int i = 0; i < element.getProperty().size(); i++) 3386 composeCodeSystemPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i); 3387 for (int i = 0; i < element.getConcept().size(); i++) 3388 composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i); 3389 } 3390 3391 protected void composeCodeSystemCodeSystemFilterComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemFilterComponent element, int index) { 3392 if (element == null) 3393 return; 3394 Complex t; 3395 if (Utilities.noString(parentType)) 3396 t = parent; 3397 else { 3398 t = parent.predicate("fhir:"+parentType+'.'+name); 3399 } 3400 composeBackboneElement(t, "filter", name, element, index); 3401 if (element.hasCodeElement()) 3402 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 3403 if (element.hasDescriptionElement()) 3404 composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 3405 for (int i = 0; i < element.getOperator().size(); i++) 3406 composeEnum(t, "CodeSystem", "operator", element.getOperator().get(i), i); 3407 if (element.hasValueElement()) 3408 composeString(t, "CodeSystem", "value", element.getValueElement(), -1); 3409 } 3410 3411 protected void composeCodeSystemPropertyComponent(Complex parent, String parentType, String name, CodeSystem.PropertyComponent 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, "property", name, element, index); 3421 if (element.hasCodeElement()) 3422 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 3423 if (element.hasUriElement()) 3424 composeUri(t, "CodeSystem", "uri", element.getUriElement(), -1); 3425 if (element.hasDescriptionElement()) 3426 composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 3427 if (element.hasTypeElement()) 3428 composeEnum(t, "CodeSystem", "type", element.getTypeElement(), -1); 3429 } 3430 3431 protected void composeCodeSystemConceptDefinitionComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionComponent 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, "concept", name, element, index); 3441 if (element.hasCodeElement()) 3442 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 3443 if (element.hasDisplayElement()) 3444 composeString(t, "CodeSystem", "display", element.getDisplayElement(), -1); 3445 if (element.hasDefinitionElement()) 3446 composeString(t, "CodeSystem", "definition", element.getDefinitionElement(), -1); 3447 for (int i = 0; i < element.getDesignation().size(); i++) 3448 composeCodeSystemConceptDefinitionDesignationComponent(t, "CodeSystem", "designation", element.getDesignation().get(i), i); 3449 for (int i = 0; i < element.getProperty().size(); i++) 3450 composeCodeSystemConceptPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i); 3451 for (int i = 0; i < element.getConcept().size(); i++) 3452 composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i); 3453 } 3454 3455 protected void composeCodeSystemConceptDefinitionDesignationComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionDesignationComponent element, int index) { 3456 if (element == null) 3457 return; 3458 Complex t; 3459 if (Utilities.noString(parentType)) 3460 t = parent; 3461 else { 3462 t = parent.predicate("fhir:"+parentType+'.'+name); 3463 } 3464 composeBackboneElement(t, "designation", name, element, index); 3465 if (element.hasLanguageElement()) 3466 composeCode(t, "CodeSystem", "language", element.getLanguageElement(), -1); 3467 if (element.hasUse()) 3468 composeCoding(t, "CodeSystem", "use", element.getUse(), -1); 3469 if (element.hasValueElement()) 3470 composeString(t, "CodeSystem", "value", element.getValueElement(), -1); 3471 } 3472 3473 protected void composeCodeSystemConceptPropertyComponent(Complex parent, String parentType, String name, CodeSystem.ConceptPropertyComponent element, int index) { 3474 if (element == null) 3475 return; 3476 Complex t; 3477 if (Utilities.noString(parentType)) 3478 t = parent; 3479 else { 3480 t = parent.predicate("fhir:"+parentType+'.'+name); 3481 } 3482 composeBackboneElement(t, "property", name, element, index); 3483 if (element.hasCodeElement()) 3484 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 3485 if (element.hasValue()) 3486 composeType(t, "CodeSystem", "value", element.getValue(), -1); 3487 } 3488 3489 protected void composeCommunication(Complex parent, String parentType, String name, Communication element, int index) { 3490 if (element == null) 3491 return; 3492 Complex t; 3493 if (Utilities.noString(parentType)) 3494 t = parent; 3495 else { 3496 t = parent.predicate("fhir:"+parentType+'.'+name); 3497 } 3498 composeDomainResource(t, "Communication", name, element, index); 3499 for (int i = 0; i < element.getIdentifier().size(); i++) 3500 composeIdentifier(t, "Communication", "identifier", element.getIdentifier().get(i), i); 3501 for (int i = 0; i < element.getDefinition().size(); i++) 3502 composeReference(t, "Communication", "definition", element.getDefinition().get(i), i); 3503 for (int i = 0; i < element.getBasedOn().size(); i++) 3504 composeReference(t, "Communication", "basedOn", element.getBasedOn().get(i), i); 3505 for (int i = 0; i < element.getPartOf().size(); i++) 3506 composeReference(t, "Communication", "partOf", element.getPartOf().get(i), i); 3507 if (element.hasStatusElement()) 3508 composeEnum(t, "Communication", "status", element.getStatusElement(), -1); 3509 if (element.hasNotDoneElement()) 3510 composeBoolean(t, "Communication", "notDone", element.getNotDoneElement(), -1); 3511 if (element.hasNotDoneReason()) 3512 composeCodeableConcept(t, "Communication", "notDoneReason", element.getNotDoneReason(), -1); 3513 for (int i = 0; i < element.getCategory().size(); i++) 3514 composeCodeableConcept(t, "Communication", "category", element.getCategory().get(i), i); 3515 for (int i = 0; i < element.getMedium().size(); i++) 3516 composeCodeableConcept(t, "Communication", "medium", element.getMedium().get(i), i); 3517 if (element.hasSubject()) 3518 composeReference(t, "Communication", "subject", element.getSubject(), -1); 3519 for (int i = 0; i < element.getRecipient().size(); i++) 3520 composeReference(t, "Communication", "recipient", element.getRecipient().get(i), i); 3521 for (int i = 0; i < element.getTopic().size(); i++) 3522 composeReference(t, "Communication", "topic", element.getTopic().get(i), i); 3523 if (element.hasContext()) 3524 composeReference(t, "Communication", "context", element.getContext(), -1); 3525 if (element.hasSentElement()) 3526 composeDateTime(t, "Communication", "sent", element.getSentElement(), -1); 3527 if (element.hasReceivedElement()) 3528 composeDateTime(t, "Communication", "received", element.getReceivedElement(), -1); 3529 if (element.hasSender()) 3530 composeReference(t, "Communication", "sender", element.getSender(), -1); 3531 for (int i = 0; i < element.getReasonCode().size(); i++) 3532 composeCodeableConcept(t, "Communication", "reasonCode", element.getReasonCode().get(i), i); 3533 for (int i = 0; i < element.getReasonReference().size(); i++) 3534 composeReference(t, "Communication", "reasonReference", element.getReasonReference().get(i), i); 3535 for (int i = 0; i < element.getPayload().size(); i++) 3536 composeCommunicationCommunicationPayloadComponent(t, "Communication", "payload", element.getPayload().get(i), i); 3537 for (int i = 0; i < element.getNote().size(); i++) 3538 composeAnnotation(t, "Communication", "note", element.getNote().get(i), i); 3539 } 3540 3541 protected void composeCommunicationCommunicationPayloadComponent(Complex parent, String parentType, String name, Communication.CommunicationPayloadComponent element, int index) { 3542 if (element == null) 3543 return; 3544 Complex t; 3545 if (Utilities.noString(parentType)) 3546 t = parent; 3547 else { 3548 t = parent.predicate("fhir:"+parentType+'.'+name); 3549 } 3550 composeBackboneElement(t, "payload", name, element, index); 3551 if (element.hasContent()) 3552 composeType(t, "Communication", "content", element.getContent(), -1); 3553 } 3554 3555 protected void composeCommunicationRequest(Complex parent, String parentType, String name, CommunicationRequest element, int index) { 3556 if (element == null) 3557 return; 3558 Complex t; 3559 if (Utilities.noString(parentType)) 3560 t = parent; 3561 else { 3562 t = parent.predicate("fhir:"+parentType+'.'+name); 3563 } 3564 composeDomainResource(t, "CommunicationRequest", name, element, index); 3565 for (int i = 0; i < element.getIdentifier().size(); i++) 3566 composeIdentifier(t, "CommunicationRequest", "identifier", element.getIdentifier().get(i), i); 3567 for (int i = 0; i < element.getBasedOn().size(); i++) 3568 composeReference(t, "CommunicationRequest", "basedOn", element.getBasedOn().get(i), i); 3569 for (int i = 0; i < element.getReplaces().size(); i++) 3570 composeReference(t, "CommunicationRequest", "replaces", element.getReplaces().get(i), i); 3571 if (element.hasGroupIdentifier()) 3572 composeIdentifier(t, "CommunicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 3573 if (element.hasStatusElement()) 3574 composeEnum(t, "CommunicationRequest", "status", element.getStatusElement(), -1); 3575 for (int i = 0; i < element.getCategory().size(); i++) 3576 composeCodeableConcept(t, "CommunicationRequest", "category", element.getCategory().get(i), i); 3577 if (element.hasPriorityElement()) 3578 composeEnum(t, "CommunicationRequest", "priority", element.getPriorityElement(), -1); 3579 for (int i = 0; i < element.getMedium().size(); i++) 3580 composeCodeableConcept(t, "CommunicationRequest", "medium", element.getMedium().get(i), i); 3581 if (element.hasSubject()) 3582 composeReference(t, "CommunicationRequest", "subject", element.getSubject(), -1); 3583 for (int i = 0; i < element.getRecipient().size(); i++) 3584 composeReference(t, "CommunicationRequest", "recipient", element.getRecipient().get(i), i); 3585 for (int i = 0; i < element.getTopic().size(); i++) 3586 composeReference(t, "CommunicationRequest", "topic", element.getTopic().get(i), i); 3587 if (element.hasContext()) 3588 composeReference(t, "CommunicationRequest", "context", element.getContext(), -1); 3589 for (int i = 0; i < element.getPayload().size(); i++) 3590 composeCommunicationRequestCommunicationRequestPayloadComponent(t, "CommunicationRequest", "payload", element.getPayload().get(i), i); 3591 if (element.hasOccurrence()) 3592 composeType(t, "CommunicationRequest", "occurrence", element.getOccurrence(), -1); 3593 if (element.hasAuthoredOnElement()) 3594 composeDateTime(t, "CommunicationRequest", "authoredOn", element.getAuthoredOnElement(), -1); 3595 if (element.hasSender()) 3596 composeReference(t, "CommunicationRequest", "sender", element.getSender(), -1); 3597 if (element.hasRequester()) 3598 composeCommunicationRequestCommunicationRequestRequesterComponent(t, "CommunicationRequest", "requester", element.getRequester(), -1); 3599 for (int i = 0; i < element.getReasonCode().size(); i++) 3600 composeCodeableConcept(t, "CommunicationRequest", "reasonCode", element.getReasonCode().get(i), i); 3601 for (int i = 0; i < element.getReasonReference().size(); i++) 3602 composeReference(t, "CommunicationRequest", "reasonReference", element.getReasonReference().get(i), i); 3603 for (int i = 0; i < element.getNote().size(); i++) 3604 composeAnnotation(t, "CommunicationRequest", "note", element.getNote().get(i), i); 3605 } 3606 3607 protected void composeCommunicationRequestCommunicationRequestPayloadComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestPayloadComponent element, int index) { 3608 if (element == null) 3609 return; 3610 Complex t; 3611 if (Utilities.noString(parentType)) 3612 t = parent; 3613 else { 3614 t = parent.predicate("fhir:"+parentType+'.'+name); 3615 } 3616 composeBackboneElement(t, "payload", name, element, index); 3617 if (element.hasContent()) 3618 composeType(t, "CommunicationRequest", "content", element.getContent(), -1); 3619 } 3620 3621 protected void composeCommunicationRequestCommunicationRequestRequesterComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestRequesterComponent element, int index) { 3622 if (element == null) 3623 return; 3624 Complex t; 3625 if (Utilities.noString(parentType)) 3626 t = parent; 3627 else { 3628 t = parent.predicate("fhir:"+parentType+'.'+name); 3629 } 3630 composeBackboneElement(t, "requester", name, element, index); 3631 if (element.hasAgent()) 3632 composeReference(t, "CommunicationRequest", "agent", element.getAgent(), -1); 3633 if (element.hasOnBehalfOf()) 3634 composeReference(t, "CommunicationRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 3635 } 3636 3637 protected void composeCompartmentDefinition(Complex parent, String parentType, String name, CompartmentDefinition element, int index) { 3638 if (element == null) 3639 return; 3640 Complex t; 3641 if (Utilities.noString(parentType)) 3642 t = parent; 3643 else { 3644 t = parent.predicate("fhir:"+parentType+'.'+name); 3645 } 3646 composeDomainResource(t, "CompartmentDefinition", name, element, index); 3647 if (element.hasUrlElement()) 3648 composeUri(t, "CompartmentDefinition", "url", element.getUrlElement(), -1); 3649 if (element.hasNameElement()) 3650 composeString(t, "CompartmentDefinition", "name", element.getNameElement(), -1); 3651 if (element.hasTitleElement()) 3652 composeString(t, "CompartmentDefinition", "title", element.getTitleElement(), -1); 3653 if (element.hasStatusElement()) 3654 composeEnum(t, "CompartmentDefinition", "status", element.getStatusElement(), -1); 3655 if (element.hasExperimentalElement()) 3656 composeBoolean(t, "CompartmentDefinition", "experimental", element.getExperimentalElement(), -1); 3657 if (element.hasDateElement()) 3658 composeDateTime(t, "CompartmentDefinition", "date", element.getDateElement(), -1); 3659 if (element.hasPublisherElement()) 3660 composeString(t, "CompartmentDefinition", "publisher", element.getPublisherElement(), -1); 3661 for (int i = 0; i < element.getContact().size(); i++) 3662 composeContactDetail(t, "CompartmentDefinition", "contact", element.getContact().get(i), i); 3663 if (element.hasDescriptionElement()) 3664 composeMarkdown(t, "CompartmentDefinition", "description", element.getDescriptionElement(), -1); 3665 if (element.hasPurposeElement()) 3666 composeMarkdown(t, "CompartmentDefinition", "purpose", element.getPurposeElement(), -1); 3667 for (int i = 0; i < element.getUseContext().size(); i++) 3668 composeUsageContext(t, "CompartmentDefinition", "useContext", element.getUseContext().get(i), i); 3669 for (int i = 0; i < element.getJurisdiction().size(); i++) 3670 composeCodeableConcept(t, "CompartmentDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 3671 if (element.hasCodeElement()) 3672 composeEnum(t, "CompartmentDefinition", "code", element.getCodeElement(), -1); 3673 if (element.hasSearchElement()) 3674 composeBoolean(t, "CompartmentDefinition", "search", element.getSearchElement(), -1); 3675 for (int i = 0; i < element.getResource().size(); i++) 3676 composeCompartmentDefinitionCompartmentDefinitionResourceComponent(t, "CompartmentDefinition", "resource", element.getResource().get(i), i); 3677 } 3678 3679 protected void composeCompartmentDefinitionCompartmentDefinitionResourceComponent(Complex parent, String parentType, String name, CompartmentDefinition.CompartmentDefinitionResourceComponent element, int index) { 3680 if (element == null) 3681 return; 3682 Complex t; 3683 if (Utilities.noString(parentType)) 3684 t = parent; 3685 else { 3686 t = parent.predicate("fhir:"+parentType+'.'+name); 3687 } 3688 composeBackboneElement(t, "resource", name, element, index); 3689 if (element.hasCodeElement()) 3690 composeCode(t, "CompartmentDefinition", "code", element.getCodeElement(), -1); 3691 for (int i = 0; i < element.getParam().size(); i++) 3692 composeString(t, "CompartmentDefinition", "param", element.getParam().get(i), i); 3693 if (element.hasDocumentationElement()) 3694 composeString(t, "CompartmentDefinition", "documentation", element.getDocumentationElement(), -1); 3695 } 3696 3697 protected void composeComposition(Complex parent, String parentType, String name, Composition element, int index) { 3698 if (element == null) 3699 return; 3700 Complex t; 3701 if (Utilities.noString(parentType)) 3702 t = parent; 3703 else { 3704 t = parent.predicate("fhir:"+parentType+'.'+name); 3705 } 3706 composeDomainResource(t, "Composition", name, element, index); 3707 if (element.hasIdentifier()) 3708 composeIdentifier(t, "Composition", "identifier", element.getIdentifier(), -1); 3709 if (element.hasStatusElement()) 3710 composeEnum(t, "Composition", "status", element.getStatusElement(), -1); 3711 if (element.hasType()) 3712 composeCodeableConcept(t, "Composition", "type", element.getType(), -1); 3713 if (element.hasClass_()) 3714 composeCodeableConcept(t, "Composition", "class", element.getClass_(), -1); 3715 if (element.hasSubject()) 3716 composeReference(t, "Composition", "subject", element.getSubject(), -1); 3717 if (element.hasEncounter()) 3718 composeReference(t, "Composition", "encounter", element.getEncounter(), -1); 3719 if (element.hasDateElement()) 3720 composeDateTime(t, "Composition", "date", element.getDateElement(), -1); 3721 for (int i = 0; i < element.getAuthor().size(); i++) 3722 composeReference(t, "Composition", "author", element.getAuthor().get(i), i); 3723 if (element.hasTitleElement()) 3724 composeString(t, "Composition", "title", element.getTitleElement(), -1); 3725 if (element.hasConfidentialityElement()) 3726 composeEnum(t, "Composition", "confidentiality", element.getConfidentialityElement(), -1); 3727 for (int i = 0; i < element.getAttester().size(); i++) 3728 composeCompositionCompositionAttesterComponent(t, "Composition", "attester", element.getAttester().get(i), i); 3729 if (element.hasCustodian()) 3730 composeReference(t, "Composition", "custodian", element.getCustodian(), -1); 3731 for (int i = 0; i < element.getRelatesTo().size(); i++) 3732 composeCompositionCompositionRelatesToComponent(t, "Composition", "relatesTo", element.getRelatesTo().get(i), i); 3733 for (int i = 0; i < element.getEvent().size(); i++) 3734 composeCompositionCompositionEventComponent(t, "Composition", "event", element.getEvent().get(i), i); 3735 for (int i = 0; i < element.getSection().size(); i++) 3736 composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i); 3737 } 3738 3739 protected void composeCompositionCompositionAttesterComponent(Complex parent, String parentType, String name, Composition.CompositionAttesterComponent element, int index) { 3740 if (element == null) 3741 return; 3742 Complex t; 3743 if (Utilities.noString(parentType)) 3744 t = parent; 3745 else { 3746 t = parent.predicate("fhir:"+parentType+'.'+name); 3747 } 3748 composeBackboneElement(t, "attester", name, element, index); 3749 for (int i = 0; i < element.getMode().size(); i++) 3750 composeEnum(t, "Composition", "mode", element.getMode().get(i), i); 3751 if (element.hasTimeElement()) 3752 composeDateTime(t, "Composition", "time", element.getTimeElement(), -1); 3753 if (element.hasParty()) 3754 composeReference(t, "Composition", "party", element.getParty(), -1); 3755 } 3756 3757 protected void composeCompositionCompositionRelatesToComponent(Complex parent, String parentType, String name, Composition.CompositionRelatesToComponent element, int index) { 3758 if (element == null) 3759 return; 3760 Complex t; 3761 if (Utilities.noString(parentType)) 3762 t = parent; 3763 else { 3764 t = parent.predicate("fhir:"+parentType+'.'+name); 3765 } 3766 composeBackboneElement(t, "relatesTo", name, element, index); 3767 if (element.hasCodeElement()) 3768 composeEnum(t, "Composition", "code", element.getCodeElement(), -1); 3769 if (element.hasTarget()) 3770 composeType(t, "Composition", "target", element.getTarget(), -1); 3771 } 3772 3773 protected void composeCompositionCompositionEventComponent(Complex parent, String parentType, String name, Composition.CompositionEventComponent element, int index) { 3774 if (element == null) 3775 return; 3776 Complex t; 3777 if (Utilities.noString(parentType)) 3778 t = parent; 3779 else { 3780 t = parent.predicate("fhir:"+parentType+'.'+name); 3781 } 3782 composeBackboneElement(t, "event", name, element, index); 3783 for (int i = 0; i < element.getCode().size(); i++) 3784 composeCodeableConcept(t, "Composition", "code", element.getCode().get(i), i); 3785 if (element.hasPeriod()) 3786 composePeriod(t, "Composition", "period", element.getPeriod(), -1); 3787 for (int i = 0; i < element.getDetail().size(); i++) 3788 composeReference(t, "Composition", "detail", element.getDetail().get(i), i); 3789 } 3790 3791 protected void composeCompositionSectionComponent(Complex parent, String parentType, String name, Composition.SectionComponent element, int index) { 3792 if (element == null) 3793 return; 3794 Complex t; 3795 if (Utilities.noString(parentType)) 3796 t = parent; 3797 else { 3798 t = parent.predicate("fhir:"+parentType+'.'+name); 3799 } 3800 composeBackboneElement(t, "section", name, element, index); 3801 if (element.hasTitleElement()) 3802 composeString(t, "Composition", "title", element.getTitleElement(), -1); 3803 if (element.hasCode()) 3804 composeCodeableConcept(t, "Composition", "code", element.getCode(), -1); 3805 if (element.hasText()) 3806 composeNarrative(t, "Composition", "text", element.getText(), -1); 3807 if (element.hasModeElement()) 3808 composeEnum(t, "Composition", "mode", element.getModeElement(), -1); 3809 if (element.hasOrderedBy()) 3810 composeCodeableConcept(t, "Composition", "orderedBy", element.getOrderedBy(), -1); 3811 for (int i = 0; i < element.getEntry().size(); i++) 3812 composeReference(t, "Composition", "entry", element.getEntry().get(i), i); 3813 if (element.hasEmptyReason()) 3814 composeCodeableConcept(t, "Composition", "emptyReason", element.getEmptyReason(), -1); 3815 for (int i = 0; i < element.getSection().size(); i++) 3816 composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i); 3817 } 3818 3819 protected void composeConceptMap(Complex parent, String parentType, String name, ConceptMap element, int index) { 3820 if (element == null) 3821 return; 3822 Complex t; 3823 if (Utilities.noString(parentType)) 3824 t = parent; 3825 else { 3826 t = parent.predicate("fhir:"+parentType+'.'+name); 3827 } 3828 composeDomainResource(t, "ConceptMap", name, element, index); 3829 if (element.hasUrlElement()) 3830 composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1); 3831 if (element.hasIdentifier()) 3832 composeIdentifier(t, "ConceptMap", "identifier", element.getIdentifier(), -1); 3833 if (element.hasVersionElement()) 3834 composeString(t, "ConceptMap", "version", element.getVersionElement(), -1); 3835 if (element.hasNameElement()) 3836 composeString(t, "ConceptMap", "name", element.getNameElement(), -1); 3837 if (element.hasTitleElement()) 3838 composeString(t, "ConceptMap", "title", element.getTitleElement(), -1); 3839 if (element.hasStatusElement()) 3840 composeEnum(t, "ConceptMap", "status", element.getStatusElement(), -1); 3841 if (element.hasExperimentalElement()) 3842 composeBoolean(t, "ConceptMap", "experimental", element.getExperimentalElement(), -1); 3843 if (element.hasDateElement()) 3844 composeDateTime(t, "ConceptMap", "date", element.getDateElement(), -1); 3845 if (element.hasPublisherElement()) 3846 composeString(t, "ConceptMap", "publisher", element.getPublisherElement(), -1); 3847 for (int i = 0; i < element.getContact().size(); i++) 3848 composeContactDetail(t, "ConceptMap", "contact", element.getContact().get(i), i); 3849 if (element.hasDescriptionElement()) 3850 composeMarkdown(t, "ConceptMap", "description", element.getDescriptionElement(), -1); 3851 for (int i = 0; i < element.getUseContext().size(); i++) 3852 composeUsageContext(t, "ConceptMap", "useContext", element.getUseContext().get(i), i); 3853 for (int i = 0; i < element.getJurisdiction().size(); i++) 3854 composeCodeableConcept(t, "ConceptMap", "jurisdiction", element.getJurisdiction().get(i), i); 3855 if (element.hasPurposeElement()) 3856 composeMarkdown(t, "ConceptMap", "purpose", element.getPurposeElement(), -1); 3857 if (element.hasCopyrightElement()) 3858 composeMarkdown(t, "ConceptMap", "copyright", element.getCopyrightElement(), -1); 3859 if (element.hasSource()) 3860 composeType(t, "ConceptMap", "source", element.getSource(), -1); 3861 if (element.hasTarget()) 3862 composeType(t, "ConceptMap", "target", element.getTarget(), -1); 3863 for (int i = 0; i < element.getGroup().size(); i++) 3864 composeConceptMapConceptMapGroupComponent(t, "ConceptMap", "group", element.getGroup().get(i), i); 3865 } 3866 3867 protected void composeConceptMapConceptMapGroupComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupComponent element, int index) { 3868 if (element == null) 3869 return; 3870 Complex t; 3871 if (Utilities.noString(parentType)) 3872 t = parent; 3873 else { 3874 t = parent.predicate("fhir:"+parentType+'.'+name); 3875 } 3876 composeBackboneElement(t, "group", name, element, index); 3877 if (element.hasSourceElement()) 3878 composeUri(t, "ConceptMap", "source", element.getSourceElement(), -1); 3879 if (element.hasSourceVersionElement()) 3880 composeString(t, "ConceptMap", "sourceVersion", element.getSourceVersionElement(), -1); 3881 if (element.hasTargetElement()) 3882 composeUri(t, "ConceptMap", "target", element.getTargetElement(), -1); 3883 if (element.hasTargetVersionElement()) 3884 composeString(t, "ConceptMap", "targetVersion", element.getTargetVersionElement(), -1); 3885 for (int i = 0; i < element.getElement().size(); i++) 3886 composeConceptMapSourceElementComponent(t, "ConceptMap", "element", element.getElement().get(i), i); 3887 if (element.hasUnmapped()) 3888 composeConceptMapConceptMapGroupUnmappedComponent(t, "ConceptMap", "unmapped", element.getUnmapped(), -1); 3889 } 3890 3891 protected void composeConceptMapSourceElementComponent(Complex parent, String parentType, String name, ConceptMap.SourceElementComponent element, int index) { 3892 if (element == null) 3893 return; 3894 Complex t; 3895 if (Utilities.noString(parentType)) 3896 t = parent; 3897 else { 3898 t = parent.predicate("fhir:"+parentType+'.'+name); 3899 } 3900 composeBackboneElement(t, "element", name, element, index); 3901 if (element.hasCodeElement()) 3902 composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1); 3903 if (element.hasDisplayElement()) 3904 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 3905 for (int i = 0; i < element.getTarget().size(); i++) 3906 composeConceptMapTargetElementComponent(t, "ConceptMap", "target", element.getTarget().get(i), i); 3907 } 3908 3909 protected void composeConceptMapTargetElementComponent(Complex parent, String parentType, String name, ConceptMap.TargetElementComponent element, int index) { 3910 if (element == null) 3911 return; 3912 Complex t; 3913 if (Utilities.noString(parentType)) 3914 t = parent; 3915 else { 3916 t = parent.predicate("fhir:"+parentType+'.'+name); 3917 } 3918 composeBackboneElement(t, "target", name, element, index); 3919 if (element.hasCodeElement()) 3920 composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1); 3921 if (element.hasDisplayElement()) 3922 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 3923 if (element.hasEquivalenceElement()) 3924 composeEnum(t, "ConceptMap", "equivalence", element.getEquivalenceElement(), -1); 3925 if (element.hasCommentElement()) 3926 composeString(t, "ConceptMap", "comment", element.getCommentElement(), -1); 3927 for (int i = 0; i < element.getDependsOn().size(); i++) 3928 composeConceptMapOtherElementComponent(t, "ConceptMap", "dependsOn", element.getDependsOn().get(i), i); 3929 for (int i = 0; i < element.getProduct().size(); i++) 3930 composeConceptMapOtherElementComponent(t, "ConceptMap", "product", element.getProduct().get(i), i); 3931 } 3932 3933 protected void composeConceptMapOtherElementComponent(Complex parent, String parentType, String name, ConceptMap.OtherElementComponent element, int index) { 3934 if (element == null) 3935 return; 3936 Complex t; 3937 if (Utilities.noString(parentType)) 3938 t = parent; 3939 else { 3940 t = parent.predicate("fhir:"+parentType+'.'+name); 3941 } 3942 composeBackboneElement(t, "dependsOn", name, element, index); 3943 if (element.hasPropertyElement()) 3944 composeUri(t, "ConceptMap", "property", element.getPropertyElement(), -1); 3945 if (element.hasSystemElement()) 3946 composeUri(t, "ConceptMap", "system", element.getSystemElement(), -1); 3947 if (element.hasCodeElement()) 3948 composeString(t, "ConceptMap", "code", element.getCodeElement(), -1); 3949 if (element.hasDisplayElement()) 3950 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 3951 } 3952 3953 protected void composeConceptMapConceptMapGroupUnmappedComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupUnmappedComponent 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, "unmapped", name, element, index); 3963 if (element.hasModeElement()) 3964 composeEnum(t, "ConceptMap", "mode", element.getModeElement(), -1); 3965 if (element.hasCodeElement()) 3966 composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1); 3967 if (element.hasDisplayElement()) 3968 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 3969 if (element.hasUrlElement()) 3970 composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1); 3971 } 3972 3973 protected void composeCondition(Complex parent, String parentType, String name, Condition 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 composeDomainResource(t, "Condition", name, element, index); 3983 for (int i = 0; i < element.getIdentifier().size(); i++) 3984 composeIdentifier(t, "Condition", "identifier", element.getIdentifier().get(i), i); 3985 if (element.hasClinicalStatusElement()) 3986 composeEnum(t, "Condition", "clinicalStatus", element.getClinicalStatusElement(), -1); 3987 if (element.hasVerificationStatusElement()) 3988 composeEnum(t, "Condition", "verificationStatus", element.getVerificationStatusElement(), -1); 3989 for (int i = 0; i < element.getCategory().size(); i++) 3990 composeCodeableConcept(t, "Condition", "category", element.getCategory().get(i), i); 3991 if (element.hasSeverity()) 3992 composeCodeableConcept(t, "Condition", "severity", element.getSeverity(), -1); 3993 if (element.hasCode()) 3994 composeCodeableConcept(t, "Condition", "code", element.getCode(), -1); 3995 for (int i = 0; i < element.getBodySite().size(); i++) 3996 composeCodeableConcept(t, "Condition", "bodySite", element.getBodySite().get(i), i); 3997 if (element.hasSubject()) 3998 composeReference(t, "Condition", "subject", element.getSubject(), -1); 3999 if (element.hasContext()) 4000 composeReference(t, "Condition", "context", element.getContext(), -1); 4001 if (element.hasOnset()) 4002 composeType(t, "Condition", "onset", element.getOnset(), -1); 4003 if (element.hasAbatement()) 4004 composeType(t, "Condition", "abatement", element.getAbatement(), -1); 4005 if (element.hasAssertedDateElement()) 4006 composeDateTime(t, "Condition", "assertedDate", element.getAssertedDateElement(), -1); 4007 if (element.hasAsserter()) 4008 composeReference(t, "Condition", "asserter", element.getAsserter(), -1); 4009 if (element.hasStage()) 4010 composeConditionConditionStageComponent(t, "Condition", "stage", element.getStage(), -1); 4011 for (int i = 0; i < element.getEvidence().size(); i++) 4012 composeConditionConditionEvidenceComponent(t, "Condition", "evidence", element.getEvidence().get(i), i); 4013 for (int i = 0; i < element.getNote().size(); i++) 4014 composeAnnotation(t, "Condition", "note", element.getNote().get(i), i); 4015 } 4016 4017 protected void composeConditionConditionStageComponent(Complex parent, String parentType, String name, Condition.ConditionStageComponent element, int index) { 4018 if (element == null) 4019 return; 4020 Complex t; 4021 if (Utilities.noString(parentType)) 4022 t = parent; 4023 else { 4024 t = parent.predicate("fhir:"+parentType+'.'+name); 4025 } 4026 composeBackboneElement(t, "stage", name, element, index); 4027 if (element.hasSummary()) 4028 composeCodeableConcept(t, "Condition", "summary", element.getSummary(), -1); 4029 for (int i = 0; i < element.getAssessment().size(); i++) 4030 composeReference(t, "Condition", "assessment", element.getAssessment().get(i), i); 4031 } 4032 4033 protected void composeConditionConditionEvidenceComponent(Complex parent, String parentType, String name, Condition.ConditionEvidenceComponent element, int index) { 4034 if (element == null) 4035 return; 4036 Complex t; 4037 if (Utilities.noString(parentType)) 4038 t = parent; 4039 else { 4040 t = parent.predicate("fhir:"+parentType+'.'+name); 4041 } 4042 composeBackboneElement(t, "evidence", name, element, index); 4043 for (int i = 0; i < element.getCode().size(); i++) 4044 composeCodeableConcept(t, "Condition", "code", element.getCode().get(i), i); 4045 for (int i = 0; i < element.getDetail().size(); i++) 4046 composeReference(t, "Condition", "detail", element.getDetail().get(i), i); 4047 } 4048 4049 protected void composeConsent(Complex parent, String parentType, String name, Consent element, int index) { 4050 if (element == null) 4051 return; 4052 Complex t; 4053 if (Utilities.noString(parentType)) 4054 t = parent; 4055 else { 4056 t = parent.predicate("fhir:"+parentType+'.'+name); 4057 } 4058 composeDomainResource(t, "Consent", name, element, index); 4059 if (element.hasIdentifier()) 4060 composeIdentifier(t, "Consent", "identifier", element.getIdentifier(), -1); 4061 if (element.hasStatusElement()) 4062 composeEnum(t, "Consent", "status", element.getStatusElement(), -1); 4063 for (int i = 0; i < element.getCategory().size(); i++) 4064 composeCodeableConcept(t, "Consent", "category", element.getCategory().get(i), i); 4065 if (element.hasPatient()) 4066 composeReference(t, "Consent", "patient", element.getPatient(), -1); 4067 if (element.hasPeriod()) 4068 composePeriod(t, "Consent", "period", element.getPeriod(), -1); 4069 if (element.hasDateTimeElement()) 4070 composeDateTime(t, "Consent", "dateTime", element.getDateTimeElement(), -1); 4071 for (int i = 0; i < element.getConsentingParty().size(); i++) 4072 composeReference(t, "Consent", "consentingParty", element.getConsentingParty().get(i), i); 4073 for (int i = 0; i < element.getActor().size(); i++) 4074 composeConsentConsentActorComponent(t, "Consent", "actor", element.getActor().get(i), i); 4075 for (int i = 0; i < element.getAction().size(); i++) 4076 composeCodeableConcept(t, "Consent", "action", element.getAction().get(i), i); 4077 for (int i = 0; i < element.getOrganization().size(); i++) 4078 composeReference(t, "Consent", "organization", element.getOrganization().get(i), i); 4079 if (element.hasSource()) 4080 composeType(t, "Consent", "source", element.getSource(), -1); 4081 for (int i = 0; i < element.getPolicy().size(); i++) 4082 composeConsentConsentPolicyComponent(t, "Consent", "policy", element.getPolicy().get(i), i); 4083 if (element.hasPolicyRuleElement()) 4084 composeUri(t, "Consent", "policyRule", element.getPolicyRuleElement(), -1); 4085 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4086 composeCoding(t, "Consent", "securityLabel", element.getSecurityLabel().get(i), i); 4087 for (int i = 0; i < element.getPurpose().size(); i++) 4088 composeCoding(t, "Consent", "purpose", element.getPurpose().get(i), i); 4089 if (element.hasDataPeriod()) 4090 composePeriod(t, "Consent", "dataPeriod", element.getDataPeriod(), -1); 4091 for (int i = 0; i < element.getData().size(); i++) 4092 composeConsentConsentDataComponent(t, "Consent", "data", element.getData().get(i), i); 4093 for (int i = 0; i < element.getExcept().size(); i++) 4094 composeConsentExceptComponent(t, "Consent", "except", element.getExcept().get(i), i); 4095 } 4096 4097 protected void composeConsentConsentActorComponent(Complex parent, String parentType, String name, Consent.ConsentActorComponent element, int index) { 4098 if (element == null) 4099 return; 4100 Complex t; 4101 if (Utilities.noString(parentType)) 4102 t = parent; 4103 else { 4104 t = parent.predicate("fhir:"+parentType+'.'+name); 4105 } 4106 composeBackboneElement(t, "actor", name, element, index); 4107 if (element.hasRole()) 4108 composeCodeableConcept(t, "Consent", "role", element.getRole(), -1); 4109 if (element.hasReference()) 4110 composeReference(t, "Consent", "reference", element.getReference(), -1); 4111 } 4112 4113 protected void composeConsentConsentPolicyComponent(Complex parent, String parentType, String name, Consent.ConsentPolicyComponent element, int index) { 4114 if (element == null) 4115 return; 4116 Complex t; 4117 if (Utilities.noString(parentType)) 4118 t = parent; 4119 else { 4120 t = parent.predicate("fhir:"+parentType+'.'+name); 4121 } 4122 composeBackboneElement(t, "policy", name, element, index); 4123 if (element.hasAuthorityElement()) 4124 composeUri(t, "Consent", "authority", element.getAuthorityElement(), -1); 4125 if (element.hasUriElement()) 4126 composeUri(t, "Consent", "uri", element.getUriElement(), -1); 4127 } 4128 4129 protected void composeConsentConsentDataComponent(Complex parent, String parentType, String name, Consent.ConsentDataComponent element, int index) { 4130 if (element == null) 4131 return; 4132 Complex t; 4133 if (Utilities.noString(parentType)) 4134 t = parent; 4135 else { 4136 t = parent.predicate("fhir:"+parentType+'.'+name); 4137 } 4138 composeBackboneElement(t, "data", name, element, index); 4139 if (element.hasMeaningElement()) 4140 composeEnum(t, "Consent", "meaning", element.getMeaningElement(), -1); 4141 if (element.hasReference()) 4142 composeReference(t, "Consent", "reference", element.getReference(), -1); 4143 } 4144 4145 protected void composeConsentExceptComponent(Complex parent, String parentType, String name, Consent.ExceptComponent element, int index) { 4146 if (element == null) 4147 return; 4148 Complex t; 4149 if (Utilities.noString(parentType)) 4150 t = parent; 4151 else { 4152 t = parent.predicate("fhir:"+parentType+'.'+name); 4153 } 4154 composeBackboneElement(t, "except", name, element, index); 4155 if (element.hasTypeElement()) 4156 composeEnum(t, "Consent", "type", element.getTypeElement(), -1); 4157 if (element.hasPeriod()) 4158 composePeriod(t, "Consent", "period", element.getPeriod(), -1); 4159 for (int i = 0; i < element.getActor().size(); i++) 4160 composeConsentExceptActorComponent(t, "Consent", "actor", element.getActor().get(i), i); 4161 for (int i = 0; i < element.getAction().size(); i++) 4162 composeCodeableConcept(t, "Consent", "action", element.getAction().get(i), i); 4163 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4164 composeCoding(t, "Consent", "securityLabel", element.getSecurityLabel().get(i), i); 4165 for (int i = 0; i < element.getPurpose().size(); i++) 4166 composeCoding(t, "Consent", "purpose", element.getPurpose().get(i), i); 4167 for (int i = 0; i < element.getClass_().size(); i++) 4168 composeCoding(t, "Consent", "class", element.getClass_().get(i), i); 4169 for (int i = 0; i < element.getCode().size(); i++) 4170 composeCoding(t, "Consent", "code", element.getCode().get(i), i); 4171 if (element.hasDataPeriod()) 4172 composePeriod(t, "Consent", "dataPeriod", element.getDataPeriod(), -1); 4173 for (int i = 0; i < element.getData().size(); i++) 4174 composeConsentExceptDataComponent(t, "Consent", "data", element.getData().get(i), i); 4175 } 4176 4177 protected void composeConsentExceptActorComponent(Complex parent, String parentType, String name, Consent.ExceptActorComponent element, int index) { 4178 if (element == null) 4179 return; 4180 Complex t; 4181 if (Utilities.noString(parentType)) 4182 t = parent; 4183 else { 4184 t = parent.predicate("fhir:"+parentType+'.'+name); 4185 } 4186 composeBackboneElement(t, "actor", name, element, index); 4187 if (element.hasRole()) 4188 composeCodeableConcept(t, "Consent", "role", element.getRole(), -1); 4189 if (element.hasReference()) 4190 composeReference(t, "Consent", "reference", element.getReference(), -1); 4191 } 4192 4193 protected void composeConsentExceptDataComponent(Complex parent, String parentType, String name, Consent.ExceptDataComponent element, int index) { 4194 if (element == null) 4195 return; 4196 Complex t; 4197 if (Utilities.noString(parentType)) 4198 t = parent; 4199 else { 4200 t = parent.predicate("fhir:"+parentType+'.'+name); 4201 } 4202 composeBackboneElement(t, "data", name, element, index); 4203 if (element.hasMeaningElement()) 4204 composeEnum(t, "Consent", "meaning", element.getMeaningElement(), -1); 4205 if (element.hasReference()) 4206 composeReference(t, "Consent", "reference", element.getReference(), -1); 4207 } 4208 4209 protected void composeContract(Complex parent, String parentType, String name, Contract element, int index) { 4210 if (element == null) 4211 return; 4212 Complex t; 4213 if (Utilities.noString(parentType)) 4214 t = parent; 4215 else { 4216 t = parent.predicate("fhir:"+parentType+'.'+name); 4217 } 4218 composeDomainResource(t, "Contract", name, element, index); 4219 if (element.hasIdentifier()) 4220 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 4221 if (element.hasStatusElement()) 4222 composeEnum(t, "Contract", "status", element.getStatusElement(), -1); 4223 if (element.hasIssuedElement()) 4224 composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1); 4225 if (element.hasApplies()) 4226 composePeriod(t, "Contract", "applies", element.getApplies(), -1); 4227 for (int i = 0; i < element.getSubject().size(); i++) 4228 composeReference(t, "Contract", "subject", element.getSubject().get(i), i); 4229 for (int i = 0; i < element.getTopic().size(); i++) 4230 composeReference(t, "Contract", "topic", element.getTopic().get(i), i); 4231 for (int i = 0; i < element.getAuthority().size(); i++) 4232 composeReference(t, "Contract", "authority", element.getAuthority().get(i), i); 4233 for (int i = 0; i < element.getDomain().size(); i++) 4234 composeReference(t, "Contract", "domain", element.getDomain().get(i), i); 4235 if (element.hasType()) 4236 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 4237 for (int i = 0; i < element.getSubType().size(); i++) 4238 composeCodeableConcept(t, "Contract", "subType", element.getSubType().get(i), i); 4239 for (int i = 0; i < element.getAction().size(); i++) 4240 composeCodeableConcept(t, "Contract", "action", element.getAction().get(i), i); 4241 for (int i = 0; i < element.getActionReason().size(); i++) 4242 composeCodeableConcept(t, "Contract", "actionReason", element.getActionReason().get(i), i); 4243 if (element.hasDecisionType()) 4244 composeCodeableConcept(t, "Contract", "decisionType", element.getDecisionType(), -1); 4245 if (element.hasContentDerivative()) 4246 composeCodeableConcept(t, "Contract", "contentDerivative", element.getContentDerivative(), -1); 4247 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4248 composeCoding(t, "Contract", "securityLabel", element.getSecurityLabel().get(i), i); 4249 for (int i = 0; i < element.getAgent().size(); i++) 4250 composeContractAgentComponent(t, "Contract", "agent", element.getAgent().get(i), i); 4251 for (int i = 0; i < element.getSigner().size(); i++) 4252 composeContractSignatoryComponent(t, "Contract", "signer", element.getSigner().get(i), i); 4253 for (int i = 0; i < element.getValuedItem().size(); i++) 4254 composeContractValuedItemComponent(t, "Contract", "valuedItem", element.getValuedItem().get(i), i); 4255 for (int i = 0; i < element.getTerm().size(); i++) 4256 composeContractTermComponent(t, "Contract", "term", element.getTerm().get(i), i); 4257 if (element.hasBinding()) 4258 composeType(t, "Contract", "binding", element.getBinding(), -1); 4259 for (int i = 0; i < element.getFriendly().size(); i++) 4260 composeContractFriendlyLanguageComponent(t, "Contract", "friendly", element.getFriendly().get(i), i); 4261 for (int i = 0; i < element.getLegal().size(); i++) 4262 composeContractLegalLanguageComponent(t, "Contract", "legal", element.getLegal().get(i), i); 4263 for (int i = 0; i < element.getRule().size(); i++) 4264 composeContractComputableLanguageComponent(t, "Contract", "rule", element.getRule().get(i), i); 4265 } 4266 4267 protected void composeContractAgentComponent(Complex parent, String parentType, String name, Contract.AgentComponent element, int index) { 4268 if (element == null) 4269 return; 4270 Complex t; 4271 if (Utilities.noString(parentType)) 4272 t = parent; 4273 else { 4274 t = parent.predicate("fhir:"+parentType+'.'+name); 4275 } 4276 composeBackboneElement(t, "agent", name, element, index); 4277 if (element.hasActor()) 4278 composeReference(t, "Contract", "actor", element.getActor(), -1); 4279 for (int i = 0; i < element.getRole().size(); i++) 4280 composeCodeableConcept(t, "Contract", "role", element.getRole().get(i), i); 4281 } 4282 4283 protected void composeContractSignatoryComponent(Complex parent, String parentType, String name, Contract.SignatoryComponent element, int index) { 4284 if (element == null) 4285 return; 4286 Complex t; 4287 if (Utilities.noString(parentType)) 4288 t = parent; 4289 else { 4290 t = parent.predicate("fhir:"+parentType+'.'+name); 4291 } 4292 composeBackboneElement(t, "signer", name, element, index); 4293 if (element.hasType()) 4294 composeCoding(t, "Contract", "type", element.getType(), -1); 4295 if (element.hasParty()) 4296 composeReference(t, "Contract", "party", element.getParty(), -1); 4297 for (int i = 0; i < element.getSignature().size(); i++) 4298 composeSignature(t, "Contract", "signature", element.getSignature().get(i), i); 4299 } 4300 4301 protected void composeContractValuedItemComponent(Complex parent, String parentType, String name, Contract.ValuedItemComponent element, int index) { 4302 if (element == null) 4303 return; 4304 Complex t; 4305 if (Utilities.noString(parentType)) 4306 t = parent; 4307 else { 4308 t = parent.predicate("fhir:"+parentType+'.'+name); 4309 } 4310 composeBackboneElement(t, "valuedItem", name, element, index); 4311 if (element.hasEntity()) 4312 composeType(t, "Contract", "entity", element.getEntity(), -1); 4313 if (element.hasIdentifier()) 4314 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 4315 if (element.hasEffectiveTimeElement()) 4316 composeDateTime(t, "Contract", "effectiveTime", element.getEffectiveTimeElement(), -1); 4317 if (element.hasQuantity()) 4318 composeQuantity(t, "Contract", "quantity", element.getQuantity(), -1); 4319 if (element.hasUnitPrice()) 4320 composeMoney(t, "Contract", "unitPrice", element.getUnitPrice(), -1); 4321 if (element.hasFactorElement()) 4322 composeDecimal(t, "Contract", "factor", element.getFactorElement(), -1); 4323 if (element.hasPointsElement()) 4324 composeDecimal(t, "Contract", "points", element.getPointsElement(), -1); 4325 if (element.hasNet()) 4326 composeMoney(t, "Contract", "net", element.getNet(), -1); 4327 } 4328 4329 protected void composeContractTermComponent(Complex parent, String parentType, String name, Contract.TermComponent element, int index) { 4330 if (element == null) 4331 return; 4332 Complex t; 4333 if (Utilities.noString(parentType)) 4334 t = parent; 4335 else { 4336 t = parent.predicate("fhir:"+parentType+'.'+name); 4337 } 4338 composeBackboneElement(t, "term", name, element, index); 4339 if (element.hasIdentifier()) 4340 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 4341 if (element.hasIssuedElement()) 4342 composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1); 4343 if (element.hasApplies()) 4344 composePeriod(t, "Contract", "applies", element.getApplies(), -1); 4345 if (element.hasType()) 4346 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 4347 if (element.hasSubType()) 4348 composeCodeableConcept(t, "Contract", "subType", element.getSubType(), -1); 4349 for (int i = 0; i < element.getTopic().size(); i++) 4350 composeReference(t, "Contract", "topic", element.getTopic().get(i), i); 4351 for (int i = 0; i < element.getAction().size(); i++) 4352 composeCodeableConcept(t, "Contract", "action", element.getAction().get(i), i); 4353 for (int i = 0; i < element.getActionReason().size(); i++) 4354 composeCodeableConcept(t, "Contract", "actionReason", element.getActionReason().get(i), i); 4355 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4356 composeCoding(t, "Contract", "securityLabel", element.getSecurityLabel().get(i), i); 4357 for (int i = 0; i < element.getAgent().size(); i++) 4358 composeContractTermAgentComponent(t, "Contract", "agent", element.getAgent().get(i), i); 4359 if (element.hasTextElement()) 4360 composeString(t, "Contract", "text", element.getTextElement(), -1); 4361 for (int i = 0; i < element.getValuedItem().size(); i++) 4362 composeContractTermValuedItemComponent(t, "Contract", "valuedItem", element.getValuedItem().get(i), i); 4363 for (int i = 0; i < element.getGroup().size(); i++) 4364 composeContractTermComponent(t, "Contract", "group", element.getGroup().get(i), i); 4365 } 4366 4367 protected void composeContractTermAgentComponent(Complex parent, String parentType, String name, Contract.TermAgentComponent element, int index) { 4368 if (element == null) 4369 return; 4370 Complex t; 4371 if (Utilities.noString(parentType)) 4372 t = parent; 4373 else { 4374 t = parent.predicate("fhir:"+parentType+'.'+name); 4375 } 4376 composeBackboneElement(t, "agent", name, element, index); 4377 if (element.hasActor()) 4378 composeReference(t, "Contract", "actor", element.getActor(), -1); 4379 for (int i = 0; i < element.getRole().size(); i++) 4380 composeCodeableConcept(t, "Contract", "role", element.getRole().get(i), i); 4381 } 4382 4383 protected void composeContractTermValuedItemComponent(Complex parent, String parentType, String name, Contract.TermValuedItemComponent element, int index) { 4384 if (element == null) 4385 return; 4386 Complex t; 4387 if (Utilities.noString(parentType)) 4388 t = parent; 4389 else { 4390 t = parent.predicate("fhir:"+parentType+'.'+name); 4391 } 4392 composeBackboneElement(t, "valuedItem", name, element, index); 4393 if (element.hasEntity()) 4394 composeType(t, "Contract", "entity", element.getEntity(), -1); 4395 if (element.hasIdentifier()) 4396 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 4397 if (element.hasEffectiveTimeElement()) 4398 composeDateTime(t, "Contract", "effectiveTime", element.getEffectiveTimeElement(), -1); 4399 if (element.hasQuantity()) 4400 composeQuantity(t, "Contract", "quantity", element.getQuantity(), -1); 4401 if (element.hasUnitPrice()) 4402 composeMoney(t, "Contract", "unitPrice", element.getUnitPrice(), -1); 4403 if (element.hasFactorElement()) 4404 composeDecimal(t, "Contract", "factor", element.getFactorElement(), -1); 4405 if (element.hasPointsElement()) 4406 composeDecimal(t, "Contract", "points", element.getPointsElement(), -1); 4407 if (element.hasNet()) 4408 composeMoney(t, "Contract", "net", element.getNet(), -1); 4409 } 4410 4411 protected void composeContractFriendlyLanguageComponent(Complex parent, String parentType, String name, Contract.FriendlyLanguageComponent element, int index) { 4412 if (element == null) 4413 return; 4414 Complex t; 4415 if (Utilities.noString(parentType)) 4416 t = parent; 4417 else { 4418 t = parent.predicate("fhir:"+parentType+'.'+name); 4419 } 4420 composeBackboneElement(t, "friendly", name, element, index); 4421 if (element.hasContent()) 4422 composeType(t, "Contract", "content", element.getContent(), -1); 4423 } 4424 4425 protected void composeContractLegalLanguageComponent(Complex parent, String parentType, String name, Contract.LegalLanguageComponent element, int index) { 4426 if (element == null) 4427 return; 4428 Complex t; 4429 if (Utilities.noString(parentType)) 4430 t = parent; 4431 else { 4432 t = parent.predicate("fhir:"+parentType+'.'+name); 4433 } 4434 composeBackboneElement(t, "legal", name, element, index); 4435 if (element.hasContent()) 4436 composeType(t, "Contract", "content", element.getContent(), -1); 4437 } 4438 4439 protected void composeContractComputableLanguageComponent(Complex parent, String parentType, String name, Contract.ComputableLanguageComponent element, int index) { 4440 if (element == null) 4441 return; 4442 Complex t; 4443 if (Utilities.noString(parentType)) 4444 t = parent; 4445 else { 4446 t = parent.predicate("fhir:"+parentType+'.'+name); 4447 } 4448 composeBackboneElement(t, "rule", name, element, index); 4449 if (element.hasContent()) 4450 composeType(t, "Contract", "content", element.getContent(), -1); 4451 } 4452 4453 protected void composeCoverage(Complex parent, String parentType, String name, Coverage element, int index) { 4454 if (element == null) 4455 return; 4456 Complex t; 4457 if (Utilities.noString(parentType)) 4458 t = parent; 4459 else { 4460 t = parent.predicate("fhir:"+parentType+'.'+name); 4461 } 4462 composeDomainResource(t, "Coverage", name, element, index); 4463 for (int i = 0; i < element.getIdentifier().size(); i++) 4464 composeIdentifier(t, "Coverage", "identifier", element.getIdentifier().get(i), i); 4465 if (element.hasStatusElement()) 4466 composeEnum(t, "Coverage", "status", element.getStatusElement(), -1); 4467 if (element.hasType()) 4468 composeCodeableConcept(t, "Coverage", "type", element.getType(), -1); 4469 if (element.hasPolicyHolder()) 4470 composeReference(t, "Coverage", "policyHolder", element.getPolicyHolder(), -1); 4471 if (element.hasSubscriber()) 4472 composeReference(t, "Coverage", "subscriber", element.getSubscriber(), -1); 4473 if (element.hasSubscriberIdElement()) 4474 composeString(t, "Coverage", "subscriberId", element.getSubscriberIdElement(), -1); 4475 if (element.hasBeneficiary()) 4476 composeReference(t, "Coverage", "beneficiary", element.getBeneficiary(), -1); 4477 if (element.hasRelationship()) 4478 composeCodeableConcept(t, "Coverage", "relationship", element.getRelationship(), -1); 4479 if (element.hasPeriod()) 4480 composePeriod(t, "Coverage", "period", element.getPeriod(), -1); 4481 for (int i = 0; i < element.getPayor().size(); i++) 4482 composeReference(t, "Coverage", "payor", element.getPayor().get(i), i); 4483 if (element.hasGrouping()) 4484 composeCoverageGroupComponent(t, "Coverage", "grouping", element.getGrouping(), -1); 4485 if (element.hasDependentElement()) 4486 composeString(t, "Coverage", "dependent", element.getDependentElement(), -1); 4487 if (element.hasSequenceElement()) 4488 composeString(t, "Coverage", "sequence", element.getSequenceElement(), -1); 4489 if (element.hasOrderElement()) 4490 composePositiveInt(t, "Coverage", "order", element.getOrderElement(), -1); 4491 if (element.hasNetworkElement()) 4492 composeString(t, "Coverage", "network", element.getNetworkElement(), -1); 4493 for (int i = 0; i < element.getContract().size(); i++) 4494 composeReference(t, "Coverage", "contract", element.getContract().get(i), i); 4495 } 4496 4497 protected void composeCoverageGroupComponent(Complex parent, String parentType, String name, Coverage.GroupComponent element, int index) { 4498 if (element == null) 4499 return; 4500 Complex t; 4501 if (Utilities.noString(parentType)) 4502 t = parent; 4503 else { 4504 t = parent.predicate("fhir:"+parentType+'.'+name); 4505 } 4506 composeBackboneElement(t, "grouping", name, element, index); 4507 if (element.hasGroupElement()) 4508 composeString(t, "Coverage", "group", element.getGroupElement(), -1); 4509 if (element.hasGroupDisplayElement()) 4510 composeString(t, "Coverage", "groupDisplay", element.getGroupDisplayElement(), -1); 4511 if (element.hasSubGroupElement()) 4512 composeString(t, "Coverage", "subGroup", element.getSubGroupElement(), -1); 4513 if (element.hasSubGroupDisplayElement()) 4514 composeString(t, "Coverage", "subGroupDisplay", element.getSubGroupDisplayElement(), -1); 4515 if (element.hasPlanElement()) 4516 composeString(t, "Coverage", "plan", element.getPlanElement(), -1); 4517 if (element.hasPlanDisplayElement()) 4518 composeString(t, "Coverage", "planDisplay", element.getPlanDisplayElement(), -1); 4519 if (element.hasSubPlanElement()) 4520 composeString(t, "Coverage", "subPlan", element.getSubPlanElement(), -1); 4521 if (element.hasSubPlanDisplayElement()) 4522 composeString(t, "Coverage", "subPlanDisplay", element.getSubPlanDisplayElement(), -1); 4523 if (element.hasClass_Element()) 4524 composeString(t, "Coverage", "class", element.getClass_Element(), -1); 4525 if (element.hasClassDisplayElement()) 4526 composeString(t, "Coverage", "classDisplay", element.getClassDisplayElement(), -1); 4527 if (element.hasSubClassElement()) 4528 composeString(t, "Coverage", "subClass", element.getSubClassElement(), -1); 4529 if (element.hasSubClassDisplayElement()) 4530 composeString(t, "Coverage", "subClassDisplay", element.getSubClassDisplayElement(), -1); 4531 } 4532 4533 protected void composeDataElement(Complex parent, String parentType, String name, DataElement element, int index) { 4534 if (element == null) 4535 return; 4536 Complex t; 4537 if (Utilities.noString(parentType)) 4538 t = parent; 4539 else { 4540 t = parent.predicate("fhir:"+parentType+'.'+name); 4541 } 4542 composeDomainResource(t, "DataElement", name, element, index); 4543 if (element.hasUrlElement()) 4544 composeUri(t, "DataElement", "url", element.getUrlElement(), -1); 4545 for (int i = 0; i < element.getIdentifier().size(); i++) 4546 composeIdentifier(t, "DataElement", "identifier", element.getIdentifier().get(i), i); 4547 if (element.hasVersionElement()) 4548 composeString(t, "DataElement", "version", element.getVersionElement(), -1); 4549 if (element.hasStatusElement()) 4550 composeEnum(t, "DataElement", "status", element.getStatusElement(), -1); 4551 if (element.hasExperimentalElement()) 4552 composeBoolean(t, "DataElement", "experimental", element.getExperimentalElement(), -1); 4553 if (element.hasDateElement()) 4554 composeDateTime(t, "DataElement", "date", element.getDateElement(), -1); 4555 if (element.hasPublisherElement()) 4556 composeString(t, "DataElement", "publisher", element.getPublisherElement(), -1); 4557 if (element.hasNameElement()) 4558 composeString(t, "DataElement", "name", element.getNameElement(), -1); 4559 if (element.hasTitleElement()) 4560 composeString(t, "DataElement", "title", element.getTitleElement(), -1); 4561 for (int i = 0; i < element.getContact().size(); i++) 4562 composeContactDetail(t, "DataElement", "contact", element.getContact().get(i), i); 4563 for (int i = 0; i < element.getUseContext().size(); i++) 4564 composeUsageContext(t, "DataElement", "useContext", element.getUseContext().get(i), i); 4565 for (int i = 0; i < element.getJurisdiction().size(); i++) 4566 composeCodeableConcept(t, "DataElement", "jurisdiction", element.getJurisdiction().get(i), i); 4567 if (element.hasCopyrightElement()) 4568 composeMarkdown(t, "DataElement", "copyright", element.getCopyrightElement(), -1); 4569 if (element.hasStringencyElement()) 4570 composeEnum(t, "DataElement", "stringency", element.getStringencyElement(), -1); 4571 for (int i = 0; i < element.getMapping().size(); i++) 4572 composeDataElementDataElementMappingComponent(t, "DataElement", "mapping", element.getMapping().get(i), i); 4573 for (int i = 0; i < element.getElement().size(); i++) 4574 composeElementDefinition(t, "DataElement", "element", element.getElement().get(i), i); 4575 } 4576 4577 protected void composeDataElementDataElementMappingComponent(Complex parent, String parentType, String name, DataElement.DataElementMappingComponent element, int index) { 4578 if (element == null) 4579 return; 4580 Complex t; 4581 if (Utilities.noString(parentType)) 4582 t = parent; 4583 else { 4584 t = parent.predicate("fhir:"+parentType+'.'+name); 4585 } 4586 composeBackboneElement(t, "mapping", name, element, index); 4587 if (element.hasIdentityElement()) 4588 composeId(t, "DataElement", "identity", element.getIdentityElement(), -1); 4589 if (element.hasUriElement()) 4590 composeUri(t, "DataElement", "uri", element.getUriElement(), -1); 4591 if (element.hasNameElement()) 4592 composeString(t, "DataElement", "name", element.getNameElement(), -1); 4593 if (element.hasCommentElement()) 4594 composeString(t, "DataElement", "comment", element.getCommentElement(), -1); 4595 } 4596 4597 protected void composeDetectedIssue(Complex parent, String parentType, String name, DetectedIssue element, int index) { 4598 if (element == null) 4599 return; 4600 Complex t; 4601 if (Utilities.noString(parentType)) 4602 t = parent; 4603 else { 4604 t = parent.predicate("fhir:"+parentType+'.'+name); 4605 } 4606 composeDomainResource(t, "DetectedIssue", name, element, index); 4607 if (element.hasIdentifier()) 4608 composeIdentifier(t, "DetectedIssue", "identifier", element.getIdentifier(), -1); 4609 if (element.hasStatusElement()) 4610 composeEnum(t, "DetectedIssue", "status", element.getStatusElement(), -1); 4611 if (element.hasCategory()) 4612 composeCodeableConcept(t, "DetectedIssue", "category", element.getCategory(), -1); 4613 if (element.hasSeverityElement()) 4614 composeEnum(t, "DetectedIssue", "severity", element.getSeverityElement(), -1); 4615 if (element.hasPatient()) 4616 composeReference(t, "DetectedIssue", "patient", element.getPatient(), -1); 4617 if (element.hasDateElement()) 4618 composeDateTime(t, "DetectedIssue", "date", element.getDateElement(), -1); 4619 if (element.hasAuthor()) 4620 composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1); 4621 for (int i = 0; i < element.getImplicated().size(); i++) 4622 composeReference(t, "DetectedIssue", "implicated", element.getImplicated().get(i), i); 4623 if (element.hasDetailElement()) 4624 composeString(t, "DetectedIssue", "detail", element.getDetailElement(), -1); 4625 if (element.hasReferenceElement()) 4626 composeUri(t, "DetectedIssue", "reference", element.getReferenceElement(), -1); 4627 for (int i = 0; i < element.getMitigation().size(); i++) 4628 composeDetectedIssueDetectedIssueMitigationComponent(t, "DetectedIssue", "mitigation", element.getMitigation().get(i), i); 4629 } 4630 4631 protected void composeDetectedIssueDetectedIssueMitigationComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueMitigationComponent element, int index) { 4632 if (element == null) 4633 return; 4634 Complex t; 4635 if (Utilities.noString(parentType)) 4636 t = parent; 4637 else { 4638 t = parent.predicate("fhir:"+parentType+'.'+name); 4639 } 4640 composeBackboneElement(t, "mitigation", name, element, index); 4641 if (element.hasAction()) 4642 composeCodeableConcept(t, "DetectedIssue", "action", element.getAction(), -1); 4643 if (element.hasDateElement()) 4644 composeDateTime(t, "DetectedIssue", "date", element.getDateElement(), -1); 4645 if (element.hasAuthor()) 4646 composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1); 4647 } 4648 4649 protected void composeDevice(Complex parent, String parentType, String name, Device element, int index) { 4650 if (element == null) 4651 return; 4652 Complex t; 4653 if (Utilities.noString(parentType)) 4654 t = parent; 4655 else { 4656 t = parent.predicate("fhir:"+parentType+'.'+name); 4657 } 4658 composeDomainResource(t, "Device", name, element, index); 4659 for (int i = 0; i < element.getIdentifier().size(); i++) 4660 composeIdentifier(t, "Device", "identifier", element.getIdentifier().get(i), i); 4661 if (element.hasUdi()) 4662 composeDeviceDeviceUdiComponent(t, "Device", "udi", element.getUdi(), -1); 4663 if (element.hasStatusElement()) 4664 composeEnum(t, "Device", "status", element.getStatusElement(), -1); 4665 if (element.hasType()) 4666 composeCodeableConcept(t, "Device", "type", element.getType(), -1); 4667 if (element.hasLotNumberElement()) 4668 composeString(t, "Device", "lotNumber", element.getLotNumberElement(), -1); 4669 if (element.hasManufacturerElement()) 4670 composeString(t, "Device", "manufacturer", element.getManufacturerElement(), -1); 4671 if (element.hasManufactureDateElement()) 4672 composeDateTime(t, "Device", "manufactureDate", element.getManufactureDateElement(), -1); 4673 if (element.hasExpirationDateElement()) 4674 composeDateTime(t, "Device", "expirationDate", element.getExpirationDateElement(), -1); 4675 if (element.hasModelElement()) 4676 composeString(t, "Device", "model", element.getModelElement(), -1); 4677 if (element.hasVersionElement()) 4678 composeString(t, "Device", "version", element.getVersionElement(), -1); 4679 if (element.hasPatient()) 4680 composeReference(t, "Device", "patient", element.getPatient(), -1); 4681 if (element.hasOwner()) 4682 composeReference(t, "Device", "owner", element.getOwner(), -1); 4683 for (int i = 0; i < element.getContact().size(); i++) 4684 composeContactPoint(t, "Device", "contact", element.getContact().get(i), i); 4685 if (element.hasLocation()) 4686 composeReference(t, "Device", "location", element.getLocation(), -1); 4687 if (element.hasUrlElement()) 4688 composeUri(t, "Device", "url", element.getUrlElement(), -1); 4689 for (int i = 0; i < element.getNote().size(); i++) 4690 composeAnnotation(t, "Device", "note", element.getNote().get(i), i); 4691 for (int i = 0; i < element.getSafety().size(); i++) 4692 composeCodeableConcept(t, "Device", "safety", element.getSafety().get(i), i); 4693 } 4694 4695 protected void composeDeviceDeviceUdiComponent(Complex parent, String parentType, String name, Device.DeviceUdiComponent element, int index) { 4696 if (element == null) 4697 return; 4698 Complex t; 4699 if (Utilities.noString(parentType)) 4700 t = parent; 4701 else { 4702 t = parent.predicate("fhir:"+parentType+'.'+name); 4703 } 4704 composeBackboneElement(t, "udi", name, element, index); 4705 if (element.hasDeviceIdentifierElement()) 4706 composeString(t, "Device", "deviceIdentifier", element.getDeviceIdentifierElement(), -1); 4707 if (element.hasNameElement()) 4708 composeString(t, "Device", "name", element.getNameElement(), -1); 4709 if (element.hasJurisdictionElement()) 4710 composeUri(t, "Device", "jurisdiction", element.getJurisdictionElement(), -1); 4711 if (element.hasCarrierHRFElement()) 4712 composeString(t, "Device", "carrierHRF", element.getCarrierHRFElement(), -1); 4713 if (element.hasCarrierAIDCElement()) 4714 composeBase64Binary(t, "Device", "carrierAIDC", element.getCarrierAIDCElement(), -1); 4715 if (element.hasIssuerElement()) 4716 composeUri(t, "Device", "issuer", element.getIssuerElement(), -1); 4717 if (element.hasEntryTypeElement()) 4718 composeEnum(t, "Device", "entryType", element.getEntryTypeElement(), -1); 4719 } 4720 4721 protected void composeDeviceComponent(Complex parent, String parentType, String name, DeviceComponent element, int index) { 4722 if (element == null) 4723 return; 4724 Complex t; 4725 if (Utilities.noString(parentType)) 4726 t = parent; 4727 else { 4728 t = parent.predicate("fhir:"+parentType+'.'+name); 4729 } 4730 composeDomainResource(t, "DeviceComponent", name, element, index); 4731 if (element.hasIdentifier()) 4732 composeIdentifier(t, "DeviceComponent", "identifier", element.getIdentifier(), -1); 4733 if (element.hasType()) 4734 composeCodeableConcept(t, "DeviceComponent", "type", element.getType(), -1); 4735 if (element.hasLastSystemChangeElement()) 4736 composeInstant(t, "DeviceComponent", "lastSystemChange", element.getLastSystemChangeElement(), -1); 4737 if (element.hasSource()) 4738 composeReference(t, "DeviceComponent", "source", element.getSource(), -1); 4739 if (element.hasParent()) 4740 composeReference(t, "DeviceComponent", "parent", element.getParent(), -1); 4741 for (int i = 0; i < element.getOperationalStatus().size(); i++) 4742 composeCodeableConcept(t, "DeviceComponent", "operationalStatus", element.getOperationalStatus().get(i), i); 4743 if (element.hasParameterGroup()) 4744 composeCodeableConcept(t, "DeviceComponent", "parameterGroup", element.getParameterGroup(), -1); 4745 if (element.hasMeasurementPrincipleElement()) 4746 composeEnum(t, "DeviceComponent", "measurementPrinciple", element.getMeasurementPrincipleElement(), -1); 4747 for (int i = 0; i < element.getProductionSpecification().size(); i++) 4748 composeDeviceComponentDeviceComponentProductionSpecificationComponent(t, "DeviceComponent", "productionSpecification", element.getProductionSpecification().get(i), i); 4749 if (element.hasLanguageCode()) 4750 composeCodeableConcept(t, "DeviceComponent", "languageCode", element.getLanguageCode(), -1); 4751 } 4752 4753 protected void composeDeviceComponentDeviceComponentProductionSpecificationComponent(Complex parent, String parentType, String name, DeviceComponent.DeviceComponentProductionSpecificationComponent element, int index) { 4754 if (element == null) 4755 return; 4756 Complex t; 4757 if (Utilities.noString(parentType)) 4758 t = parent; 4759 else { 4760 t = parent.predicate("fhir:"+parentType+'.'+name); 4761 } 4762 composeBackboneElement(t, "productionSpecification", name, element, index); 4763 if (element.hasSpecType()) 4764 composeCodeableConcept(t, "DeviceComponent", "specType", element.getSpecType(), -1); 4765 if (element.hasComponentId()) 4766 composeIdentifier(t, "DeviceComponent", "componentId", element.getComponentId(), -1); 4767 if (element.hasProductionSpecElement()) 4768 composeString(t, "DeviceComponent", "productionSpec", element.getProductionSpecElement(), -1); 4769 } 4770 4771 protected void composeDeviceMetric(Complex parent, String parentType, String name, DeviceMetric element, int index) { 4772 if (element == null) 4773 return; 4774 Complex t; 4775 if (Utilities.noString(parentType)) 4776 t = parent; 4777 else { 4778 t = parent.predicate("fhir:"+parentType+'.'+name); 4779 } 4780 composeDomainResource(t, "DeviceMetric", name, element, index); 4781 if (element.hasIdentifier()) 4782 composeIdentifier(t, "DeviceMetric", "identifier", element.getIdentifier(), -1); 4783 if (element.hasType()) 4784 composeCodeableConcept(t, "DeviceMetric", "type", element.getType(), -1); 4785 if (element.hasUnit()) 4786 composeCodeableConcept(t, "DeviceMetric", "unit", element.getUnit(), -1); 4787 if (element.hasSource()) 4788 composeReference(t, "DeviceMetric", "source", element.getSource(), -1); 4789 if (element.hasParent()) 4790 composeReference(t, "DeviceMetric", "parent", element.getParent(), -1); 4791 if (element.hasOperationalStatusElement()) 4792 composeEnum(t, "DeviceMetric", "operationalStatus", element.getOperationalStatusElement(), -1); 4793 if (element.hasColorElement()) 4794 composeEnum(t, "DeviceMetric", "color", element.getColorElement(), -1); 4795 if (element.hasCategoryElement()) 4796 composeEnum(t, "DeviceMetric", "category", element.getCategoryElement(), -1); 4797 if (element.hasMeasurementPeriod()) 4798 composeTiming(t, "DeviceMetric", "measurementPeriod", element.getMeasurementPeriod(), -1); 4799 for (int i = 0; i < element.getCalibration().size(); i++) 4800 composeDeviceMetricDeviceMetricCalibrationComponent(t, "DeviceMetric", "calibration", element.getCalibration().get(i), i); 4801 } 4802 4803 protected void composeDeviceMetricDeviceMetricCalibrationComponent(Complex parent, String parentType, String name, DeviceMetric.DeviceMetricCalibrationComponent element, int index) { 4804 if (element == null) 4805 return; 4806 Complex t; 4807 if (Utilities.noString(parentType)) 4808 t = parent; 4809 else { 4810 t = parent.predicate("fhir:"+parentType+'.'+name); 4811 } 4812 composeBackboneElement(t, "calibration", name, element, index); 4813 if (element.hasTypeElement()) 4814 composeEnum(t, "DeviceMetric", "type", element.getTypeElement(), -1); 4815 if (element.hasStateElement()) 4816 composeEnum(t, "DeviceMetric", "state", element.getStateElement(), -1); 4817 if (element.hasTimeElement()) 4818 composeInstant(t, "DeviceMetric", "time", element.getTimeElement(), -1); 4819 } 4820 4821 protected void composeDeviceRequest(Complex parent, String parentType, String name, DeviceRequest element, int index) { 4822 if (element == null) 4823 return; 4824 Complex t; 4825 if (Utilities.noString(parentType)) 4826 t = parent; 4827 else { 4828 t = parent.predicate("fhir:"+parentType+'.'+name); 4829 } 4830 composeDomainResource(t, "DeviceRequest", name, element, index); 4831 for (int i = 0; i < element.getIdentifier().size(); i++) 4832 composeIdentifier(t, "DeviceRequest", "identifier", element.getIdentifier().get(i), i); 4833 for (int i = 0; i < element.getDefinition().size(); i++) 4834 composeReference(t, "DeviceRequest", "definition", element.getDefinition().get(i), i); 4835 for (int i = 0; i < element.getBasedOn().size(); i++) 4836 composeReference(t, "DeviceRequest", "basedOn", element.getBasedOn().get(i), i); 4837 for (int i = 0; i < element.getPriorRequest().size(); i++) 4838 composeReference(t, "DeviceRequest", "priorRequest", element.getPriorRequest().get(i), i); 4839 if (element.hasGroupIdentifier()) 4840 composeIdentifier(t, "DeviceRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 4841 if (element.hasStatusElement()) 4842 composeEnum(t, "DeviceRequest", "status", element.getStatusElement(), -1); 4843 if (element.hasIntent()) 4844 composeCodeableConcept(t, "DeviceRequest", "intent", element.getIntent(), -1); 4845 if (element.hasPriorityElement()) 4846 composeEnum(t, "DeviceRequest", "priority", element.getPriorityElement(), -1); 4847 if (element.hasCode()) 4848 composeType(t, "DeviceRequest", "code", element.getCode(), -1); 4849 if (element.hasSubject()) 4850 composeReference(t, "DeviceRequest", "subject", element.getSubject(), -1); 4851 if (element.hasContext()) 4852 composeReference(t, "DeviceRequest", "context", element.getContext(), -1); 4853 if (element.hasOccurrence()) 4854 composeType(t, "DeviceRequest", "occurrence", element.getOccurrence(), -1); 4855 if (element.hasAuthoredOnElement()) 4856 composeDateTime(t, "DeviceRequest", "authoredOn", element.getAuthoredOnElement(), -1); 4857 if (element.hasRequester()) 4858 composeDeviceRequestDeviceRequestRequesterComponent(t, "DeviceRequest", "requester", element.getRequester(), -1); 4859 if (element.hasPerformerType()) 4860 composeCodeableConcept(t, "DeviceRequest", "performerType", element.getPerformerType(), -1); 4861 if (element.hasPerformer()) 4862 composeReference(t, "DeviceRequest", "performer", element.getPerformer(), -1); 4863 for (int i = 0; i < element.getReasonCode().size(); i++) 4864 composeCodeableConcept(t, "DeviceRequest", "reasonCode", element.getReasonCode().get(i), i); 4865 for (int i = 0; i < element.getReasonReference().size(); i++) 4866 composeReference(t, "DeviceRequest", "reasonReference", element.getReasonReference().get(i), i); 4867 for (int i = 0; i < element.getSupportingInfo().size(); i++) 4868 composeReference(t, "DeviceRequest", "supportingInfo", element.getSupportingInfo().get(i), i); 4869 for (int i = 0; i < element.getNote().size(); i++) 4870 composeAnnotation(t, "DeviceRequest", "note", element.getNote().get(i), i); 4871 for (int i = 0; i < element.getRelevantHistory().size(); i++) 4872 composeReference(t, "DeviceRequest", "relevantHistory", element.getRelevantHistory().get(i), i); 4873 } 4874 4875 protected void composeDeviceRequestDeviceRequestRequesterComponent(Complex parent, String parentType, String name, DeviceRequest.DeviceRequestRequesterComponent element, int index) { 4876 if (element == null) 4877 return; 4878 Complex t; 4879 if (Utilities.noString(parentType)) 4880 t = parent; 4881 else { 4882 t = parent.predicate("fhir:"+parentType+'.'+name); 4883 } 4884 composeBackboneElement(t, "requester", name, element, index); 4885 if (element.hasAgent()) 4886 composeReference(t, "DeviceRequest", "agent", element.getAgent(), -1); 4887 if (element.hasOnBehalfOf()) 4888 composeReference(t, "DeviceRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 4889 } 4890 4891 protected void composeDeviceUseStatement(Complex parent, String parentType, String name, DeviceUseStatement element, int index) { 4892 if (element == null) 4893 return; 4894 Complex t; 4895 if (Utilities.noString(parentType)) 4896 t = parent; 4897 else { 4898 t = parent.predicate("fhir:"+parentType+'.'+name); 4899 } 4900 composeDomainResource(t, "DeviceUseStatement", name, element, index); 4901 for (int i = 0; i < element.getIdentifier().size(); i++) 4902 composeIdentifier(t, "DeviceUseStatement", "identifier", element.getIdentifier().get(i), i); 4903 if (element.hasStatusElement()) 4904 composeEnum(t, "DeviceUseStatement", "status", element.getStatusElement(), -1); 4905 if (element.hasSubject()) 4906 composeReference(t, "DeviceUseStatement", "subject", element.getSubject(), -1); 4907 if (element.hasWhenUsed()) 4908 composePeriod(t, "DeviceUseStatement", "whenUsed", element.getWhenUsed(), -1); 4909 if (element.hasTiming()) 4910 composeType(t, "DeviceUseStatement", "timing", element.getTiming(), -1); 4911 if (element.hasRecordedOnElement()) 4912 composeDateTime(t, "DeviceUseStatement", "recordedOn", element.getRecordedOnElement(), -1); 4913 if (element.hasSource()) 4914 composeReference(t, "DeviceUseStatement", "source", element.getSource(), -1); 4915 if (element.hasDevice()) 4916 composeReference(t, "DeviceUseStatement", "device", element.getDevice(), -1); 4917 for (int i = 0; i < element.getIndication().size(); i++) 4918 composeCodeableConcept(t, "DeviceUseStatement", "indication", element.getIndication().get(i), i); 4919 if (element.hasBodySite()) 4920 composeCodeableConcept(t, "DeviceUseStatement", "bodySite", element.getBodySite(), -1); 4921 for (int i = 0; i < element.getNote().size(); i++) 4922 composeAnnotation(t, "DeviceUseStatement", "note", element.getNote().get(i), i); 4923 } 4924 4925 protected void composeDiagnosticReport(Complex parent, String parentType, String name, DiagnosticReport element, int index) { 4926 if (element == null) 4927 return; 4928 Complex t; 4929 if (Utilities.noString(parentType)) 4930 t = parent; 4931 else { 4932 t = parent.predicate("fhir:"+parentType+'.'+name); 4933 } 4934 composeDomainResource(t, "DiagnosticReport", name, element, index); 4935 for (int i = 0; i < element.getIdentifier().size(); i++) 4936 composeIdentifier(t, "DiagnosticReport", "identifier", element.getIdentifier().get(i), i); 4937 for (int i = 0; i < element.getBasedOn().size(); i++) 4938 composeReference(t, "DiagnosticReport", "basedOn", element.getBasedOn().get(i), i); 4939 if (element.hasStatusElement()) 4940 composeEnum(t, "DiagnosticReport", "status", element.getStatusElement(), -1); 4941 if (element.hasCategory()) 4942 composeCodeableConcept(t, "DiagnosticReport", "category", element.getCategory(), -1); 4943 if (element.hasCode()) 4944 composeCodeableConcept(t, "DiagnosticReport", "code", element.getCode(), -1); 4945 if (element.hasSubject()) 4946 composeReference(t, "DiagnosticReport", "subject", element.getSubject(), -1); 4947 if (element.hasContext()) 4948 composeReference(t, "DiagnosticReport", "context", element.getContext(), -1); 4949 if (element.hasEffective()) 4950 composeType(t, "DiagnosticReport", "effective", element.getEffective(), -1); 4951 if (element.hasIssuedElement()) 4952 composeInstant(t, "DiagnosticReport", "issued", element.getIssuedElement(), -1); 4953 for (int i = 0; i < element.getPerformer().size(); i++) 4954 composeDiagnosticReportDiagnosticReportPerformerComponent(t, "DiagnosticReport", "performer", element.getPerformer().get(i), i); 4955 for (int i = 0; i < element.getSpecimen().size(); i++) 4956 composeReference(t, "DiagnosticReport", "specimen", element.getSpecimen().get(i), i); 4957 for (int i = 0; i < element.getResult().size(); i++) 4958 composeReference(t, "DiagnosticReport", "result", element.getResult().get(i), i); 4959 for (int i = 0; i < element.getImagingStudy().size(); i++) 4960 composeReference(t, "DiagnosticReport", "imagingStudy", element.getImagingStudy().get(i), i); 4961 for (int i = 0; i < element.getImage().size(); i++) 4962 composeDiagnosticReportDiagnosticReportImageComponent(t, "DiagnosticReport", "image", element.getImage().get(i), i); 4963 if (element.hasConclusionElement()) 4964 composeString(t, "DiagnosticReport", "conclusion", element.getConclusionElement(), -1); 4965 for (int i = 0; i < element.getCodedDiagnosis().size(); i++) 4966 composeCodeableConcept(t, "DiagnosticReport", "codedDiagnosis", element.getCodedDiagnosis().get(i), i); 4967 for (int i = 0; i < element.getPresentedForm().size(); i++) 4968 composeAttachment(t, "DiagnosticReport", "presentedForm", element.getPresentedForm().get(i), i); 4969 } 4970 4971 protected void composeDiagnosticReportDiagnosticReportPerformerComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportPerformerComponent element, int index) { 4972 if (element == null) 4973 return; 4974 Complex t; 4975 if (Utilities.noString(parentType)) 4976 t = parent; 4977 else { 4978 t = parent.predicate("fhir:"+parentType+'.'+name); 4979 } 4980 composeBackboneElement(t, "performer", name, element, index); 4981 if (element.hasRole()) 4982 composeCodeableConcept(t, "DiagnosticReport", "role", element.getRole(), -1); 4983 if (element.hasActor()) 4984 composeReference(t, "DiagnosticReport", "actor", element.getActor(), -1); 4985 } 4986 4987 protected void composeDiagnosticReportDiagnosticReportImageComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportImageComponent element, int index) { 4988 if (element == null) 4989 return; 4990 Complex t; 4991 if (Utilities.noString(parentType)) 4992 t = parent; 4993 else { 4994 t = parent.predicate("fhir:"+parentType+'.'+name); 4995 } 4996 composeBackboneElement(t, "image", name, element, index); 4997 if (element.hasCommentElement()) 4998 composeString(t, "DiagnosticReport", "comment", element.getCommentElement(), -1); 4999 if (element.hasLink()) 5000 composeReference(t, "DiagnosticReport", "link", element.getLink(), -1); 5001 } 5002 5003 protected void composeDocumentManifest(Complex parent, String parentType, String name, DocumentManifest element, int index) { 5004 if (element == null) 5005 return; 5006 Complex t; 5007 if (Utilities.noString(parentType)) 5008 t = parent; 5009 else { 5010 t = parent.predicate("fhir:"+parentType+'.'+name); 5011 } 5012 composeDomainResource(t, "DocumentManifest", name, element, index); 5013 if (element.hasMasterIdentifier()) 5014 composeIdentifier(t, "DocumentManifest", "masterIdentifier", element.getMasterIdentifier(), -1); 5015 for (int i = 0; i < element.getIdentifier().size(); i++) 5016 composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier().get(i), i); 5017 if (element.hasStatusElement()) 5018 composeEnum(t, "DocumentManifest", "status", element.getStatusElement(), -1); 5019 if (element.hasType()) 5020 composeCodeableConcept(t, "DocumentManifest", "type", element.getType(), -1); 5021 if (element.hasSubject()) 5022 composeReference(t, "DocumentManifest", "subject", element.getSubject(), -1); 5023 if (element.hasCreatedElement()) 5024 composeDateTime(t, "DocumentManifest", "created", element.getCreatedElement(), -1); 5025 for (int i = 0; i < element.getAuthor().size(); i++) 5026 composeReference(t, "DocumentManifest", "author", element.getAuthor().get(i), i); 5027 for (int i = 0; i < element.getRecipient().size(); i++) 5028 composeReference(t, "DocumentManifest", "recipient", element.getRecipient().get(i), i); 5029 if (element.hasSourceElement()) 5030 composeUri(t, "DocumentManifest", "source", element.getSourceElement(), -1); 5031 if (element.hasDescriptionElement()) 5032 composeString(t, "DocumentManifest", "description", element.getDescriptionElement(), -1); 5033 for (int i = 0; i < element.getContent().size(); i++) 5034 composeDocumentManifestDocumentManifestContentComponent(t, "DocumentManifest", "content", element.getContent().get(i), i); 5035 for (int i = 0; i < element.getRelated().size(); i++) 5036 composeDocumentManifestDocumentManifestRelatedComponent(t, "DocumentManifest", "related", element.getRelated().get(i), i); 5037 } 5038 5039 protected void composeDocumentManifestDocumentManifestContentComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestContentComponent element, int index) { 5040 if (element == null) 5041 return; 5042 Complex t; 5043 if (Utilities.noString(parentType)) 5044 t = parent; 5045 else { 5046 t = parent.predicate("fhir:"+parentType+'.'+name); 5047 } 5048 composeBackboneElement(t, "content", name, element, index); 5049 if (element.hasP()) 5050 composeType(t, "DocumentManifest", "p", element.getP(), -1); 5051 } 5052 5053 protected void composeDocumentManifestDocumentManifestRelatedComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestRelatedComponent element, int index) { 5054 if (element == null) 5055 return; 5056 Complex t; 5057 if (Utilities.noString(parentType)) 5058 t = parent; 5059 else { 5060 t = parent.predicate("fhir:"+parentType+'.'+name); 5061 } 5062 composeBackboneElement(t, "related", name, element, index); 5063 if (element.hasIdentifier()) 5064 composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier(), -1); 5065 if (element.hasRef()) 5066 composeReference(t, "DocumentManifest", "ref", element.getRef(), -1); 5067 } 5068 5069 protected void composeDocumentReference(Complex parent, String parentType, String name, DocumentReference element, int index) { 5070 if (element == null) 5071 return; 5072 Complex t; 5073 if (Utilities.noString(parentType)) 5074 t = parent; 5075 else { 5076 t = parent.predicate("fhir:"+parentType+'.'+name); 5077 } 5078 composeDomainResource(t, "DocumentReference", name, element, index); 5079 if (element.hasMasterIdentifier()) 5080 composeIdentifier(t, "DocumentReference", "masterIdentifier", element.getMasterIdentifier(), -1); 5081 for (int i = 0; i < element.getIdentifier().size(); i++) 5082 composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier().get(i), i); 5083 if (element.hasStatusElement()) 5084 composeEnum(t, "DocumentReference", "status", element.getStatusElement(), -1); 5085 if (element.hasDocStatusElement()) 5086 composeEnum(t, "DocumentReference", "docStatus", element.getDocStatusElement(), -1); 5087 if (element.hasType()) 5088 composeCodeableConcept(t, "DocumentReference", "type", element.getType(), -1); 5089 if (element.hasClass_()) 5090 composeCodeableConcept(t, "DocumentReference", "class", element.getClass_(), -1); 5091 if (element.hasSubject()) 5092 composeReference(t, "DocumentReference", "subject", element.getSubject(), -1); 5093 if (element.hasCreatedElement()) 5094 composeDateTime(t, "DocumentReference", "created", element.getCreatedElement(), -1); 5095 if (element.hasIndexedElement()) 5096 composeInstant(t, "DocumentReference", "indexed", element.getIndexedElement(), -1); 5097 for (int i = 0; i < element.getAuthor().size(); i++) 5098 composeReference(t, "DocumentReference", "author", element.getAuthor().get(i), i); 5099 if (element.hasAuthenticator()) 5100 composeReference(t, "DocumentReference", "authenticator", element.getAuthenticator(), -1); 5101 if (element.hasCustodian()) 5102 composeReference(t, "DocumentReference", "custodian", element.getCustodian(), -1); 5103 for (int i = 0; i < element.getRelatesTo().size(); i++) 5104 composeDocumentReferenceDocumentReferenceRelatesToComponent(t, "DocumentReference", "relatesTo", element.getRelatesTo().get(i), i); 5105 if (element.hasDescriptionElement()) 5106 composeString(t, "DocumentReference", "description", element.getDescriptionElement(), -1); 5107 for (int i = 0; i < element.getSecurityLabel().size(); i++) 5108 composeCodeableConcept(t, "DocumentReference", "securityLabel", element.getSecurityLabel().get(i), i); 5109 for (int i = 0; i < element.getContent().size(); i++) 5110 composeDocumentReferenceDocumentReferenceContentComponent(t, "DocumentReference", "content", element.getContent().get(i), i); 5111 if (element.hasContext()) 5112 composeDocumentReferenceDocumentReferenceContextComponent(t, "DocumentReference", "context", element.getContext(), -1); 5113 } 5114 5115 protected void composeDocumentReferenceDocumentReferenceRelatesToComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceRelatesToComponent element, int index) { 5116 if (element == null) 5117 return; 5118 Complex t; 5119 if (Utilities.noString(parentType)) 5120 t = parent; 5121 else { 5122 t = parent.predicate("fhir:"+parentType+'.'+name); 5123 } 5124 composeBackboneElement(t, "relatesTo", name, element, index); 5125 if (element.hasCodeElement()) 5126 composeEnum(t, "DocumentReference", "code", element.getCodeElement(), -1); 5127 if (element.hasTarget()) 5128 composeReference(t, "DocumentReference", "target", element.getTarget(), -1); 5129 } 5130 5131 protected void composeDocumentReferenceDocumentReferenceContentComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContentComponent element, int index) { 5132 if (element == null) 5133 return; 5134 Complex t; 5135 if (Utilities.noString(parentType)) 5136 t = parent; 5137 else { 5138 t = parent.predicate("fhir:"+parentType+'.'+name); 5139 } 5140 composeBackboneElement(t, "content", name, element, index); 5141 if (element.hasAttachment()) 5142 composeAttachment(t, "DocumentReference", "attachment", element.getAttachment(), -1); 5143 if (element.hasFormat()) 5144 composeCoding(t, "DocumentReference", "format", element.getFormat(), -1); 5145 } 5146 5147 protected void composeDocumentReferenceDocumentReferenceContextComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextComponent element, int index) { 5148 if (element == null) 5149 return; 5150 Complex t; 5151 if (Utilities.noString(parentType)) 5152 t = parent; 5153 else { 5154 t = parent.predicate("fhir:"+parentType+'.'+name); 5155 } 5156 composeBackboneElement(t, "context", name, element, index); 5157 if (element.hasEncounter()) 5158 composeReference(t, "DocumentReference", "encounter", element.getEncounter(), -1); 5159 for (int i = 0; i < element.getEvent().size(); i++) 5160 composeCodeableConcept(t, "DocumentReference", "event", element.getEvent().get(i), i); 5161 if (element.hasPeriod()) 5162 composePeriod(t, "DocumentReference", "period", element.getPeriod(), -1); 5163 if (element.hasFacilityType()) 5164 composeCodeableConcept(t, "DocumentReference", "facilityType", element.getFacilityType(), -1); 5165 if (element.hasPracticeSetting()) 5166 composeCodeableConcept(t, "DocumentReference", "practiceSetting", element.getPracticeSetting(), -1); 5167 if (element.hasSourcePatientInfo()) 5168 composeReference(t, "DocumentReference", "sourcePatientInfo", element.getSourcePatientInfo(), -1); 5169 for (int i = 0; i < element.getRelated().size(); i++) 5170 composeDocumentReferenceDocumentReferenceContextRelatedComponent(t, "DocumentReference", "related", element.getRelated().get(i), i); 5171 } 5172 5173 protected void composeDocumentReferenceDocumentReferenceContextRelatedComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextRelatedComponent element, int index) { 5174 if (element == null) 5175 return; 5176 Complex t; 5177 if (Utilities.noString(parentType)) 5178 t = parent; 5179 else { 5180 t = parent.predicate("fhir:"+parentType+'.'+name); 5181 } 5182 composeBackboneElement(t, "related", name, element, index); 5183 if (element.hasIdentifier()) 5184 composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier(), -1); 5185 if (element.hasRef()) 5186 composeReference(t, "DocumentReference", "ref", element.getRef(), -1); 5187 } 5188 5189 protected void composeEligibilityRequest(Complex parent, String parentType, String name, EligibilityRequest element, int index) { 5190 if (element == null) 5191 return; 5192 Complex t; 5193 if (Utilities.noString(parentType)) 5194 t = parent; 5195 else { 5196 t = parent.predicate("fhir:"+parentType+'.'+name); 5197 } 5198 composeDomainResource(t, "EligibilityRequest", name, element, index); 5199 for (int i = 0; i < element.getIdentifier().size(); i++) 5200 composeIdentifier(t, "EligibilityRequest", "identifier", element.getIdentifier().get(i), i); 5201 if (element.hasStatusElement()) 5202 composeEnum(t, "EligibilityRequest", "status", element.getStatusElement(), -1); 5203 if (element.hasPriority()) 5204 composeCodeableConcept(t, "EligibilityRequest", "priority", element.getPriority(), -1); 5205 if (element.hasPatient()) 5206 composeReference(t, "EligibilityRequest", "patient", element.getPatient(), -1); 5207 if (element.hasServiced()) 5208 composeType(t, "EligibilityRequest", "serviced", element.getServiced(), -1); 5209 if (element.hasCreatedElement()) 5210 composeDateTime(t, "EligibilityRequest", "created", element.getCreatedElement(), -1); 5211 if (element.hasEnterer()) 5212 composeReference(t, "EligibilityRequest", "enterer", element.getEnterer(), -1); 5213 if (element.hasProvider()) 5214 composeReference(t, "EligibilityRequest", "provider", element.getProvider(), -1); 5215 if (element.hasOrganization()) 5216 composeReference(t, "EligibilityRequest", "organization", element.getOrganization(), -1); 5217 if (element.hasInsurer()) 5218 composeReference(t, "EligibilityRequest", "insurer", element.getInsurer(), -1); 5219 if (element.hasFacility()) 5220 composeReference(t, "EligibilityRequest", "facility", element.getFacility(), -1); 5221 if (element.hasCoverage()) 5222 composeReference(t, "EligibilityRequest", "coverage", element.getCoverage(), -1); 5223 if (element.hasBusinessArrangementElement()) 5224 composeString(t, "EligibilityRequest", "businessArrangement", element.getBusinessArrangementElement(), -1); 5225 if (element.hasBenefitCategory()) 5226 composeCodeableConcept(t, "EligibilityRequest", "benefitCategory", element.getBenefitCategory(), -1); 5227 if (element.hasBenefitSubCategory()) 5228 composeCodeableConcept(t, "EligibilityRequest", "benefitSubCategory", element.getBenefitSubCategory(), -1); 5229 } 5230 5231 protected void composeEligibilityResponse(Complex parent, String parentType, String name, EligibilityResponse element, int index) { 5232 if (element == null) 5233 return; 5234 Complex t; 5235 if (Utilities.noString(parentType)) 5236 t = parent; 5237 else { 5238 t = parent.predicate("fhir:"+parentType+'.'+name); 5239 } 5240 composeDomainResource(t, "EligibilityResponse", name, element, index); 5241 for (int i = 0; i < element.getIdentifier().size(); i++) 5242 composeIdentifier(t, "EligibilityResponse", "identifier", element.getIdentifier().get(i), i); 5243 if (element.hasStatusElement()) 5244 composeEnum(t, "EligibilityResponse", "status", element.getStatusElement(), -1); 5245 if (element.hasCreatedElement()) 5246 composeDateTime(t, "EligibilityResponse", "created", element.getCreatedElement(), -1); 5247 if (element.hasRequestProvider()) 5248 composeReference(t, "EligibilityResponse", "requestProvider", element.getRequestProvider(), -1); 5249 if (element.hasRequestOrganization()) 5250 composeReference(t, "EligibilityResponse", "requestOrganization", element.getRequestOrganization(), -1); 5251 if (element.hasRequest()) 5252 composeReference(t, "EligibilityResponse", "request", element.getRequest(), -1); 5253 if (element.hasOutcome()) 5254 composeCodeableConcept(t, "EligibilityResponse", "outcome", element.getOutcome(), -1); 5255 if (element.hasDispositionElement()) 5256 composeString(t, "EligibilityResponse", "disposition", element.getDispositionElement(), -1); 5257 if (element.hasInsurer()) 5258 composeReference(t, "EligibilityResponse", "insurer", element.getInsurer(), -1); 5259 if (element.hasInforceElement()) 5260 composeBoolean(t, "EligibilityResponse", "inforce", element.getInforceElement(), -1); 5261 for (int i = 0; i < element.getInsurance().size(); i++) 5262 composeEligibilityResponseInsuranceComponent(t, "EligibilityResponse", "insurance", element.getInsurance().get(i), i); 5263 if (element.hasForm()) 5264 composeCodeableConcept(t, "EligibilityResponse", "form", element.getForm(), -1); 5265 for (int i = 0; i < element.getError().size(); i++) 5266 composeEligibilityResponseErrorsComponent(t, "EligibilityResponse", "error", element.getError().get(i), i); 5267 } 5268 5269 protected void composeEligibilityResponseInsuranceComponent(Complex parent, String parentType, String name, EligibilityResponse.InsuranceComponent element, int index) { 5270 if (element == null) 5271 return; 5272 Complex t; 5273 if (Utilities.noString(parentType)) 5274 t = parent; 5275 else { 5276 t = parent.predicate("fhir:"+parentType+'.'+name); 5277 } 5278 composeBackboneElement(t, "insurance", name, element, index); 5279 if (element.hasCoverage()) 5280 composeReference(t, "EligibilityResponse", "coverage", element.getCoverage(), -1); 5281 if (element.hasContract()) 5282 composeReference(t, "EligibilityResponse", "contract", element.getContract(), -1); 5283 for (int i = 0; i < element.getBenefitBalance().size(); i++) 5284 composeEligibilityResponseBenefitsComponent(t, "EligibilityResponse", "benefitBalance", element.getBenefitBalance().get(i), i); 5285 } 5286 5287 protected void composeEligibilityResponseBenefitsComponent(Complex parent, String parentType, String name, EligibilityResponse.BenefitsComponent element, int index) { 5288 if (element == null) 5289 return; 5290 Complex t; 5291 if (Utilities.noString(parentType)) 5292 t = parent; 5293 else { 5294 t = parent.predicate("fhir:"+parentType+'.'+name); 5295 } 5296 composeBackboneElement(t, "benefitBalance", name, element, index); 5297 if (element.hasCategory()) 5298 composeCodeableConcept(t, "EligibilityResponse", "category", element.getCategory(), -1); 5299 if (element.hasSubCategory()) 5300 composeCodeableConcept(t, "EligibilityResponse", "subCategory", element.getSubCategory(), -1); 5301 if (element.hasExcludedElement()) 5302 composeBoolean(t, "EligibilityResponse", "excluded", element.getExcludedElement(), -1); 5303 if (element.hasNameElement()) 5304 composeString(t, "EligibilityResponse", "name", element.getNameElement(), -1); 5305 if (element.hasDescriptionElement()) 5306 composeString(t, "EligibilityResponse", "description", element.getDescriptionElement(), -1); 5307 if (element.hasNetwork()) 5308 composeCodeableConcept(t, "EligibilityResponse", "network", element.getNetwork(), -1); 5309 if (element.hasUnit()) 5310 composeCodeableConcept(t, "EligibilityResponse", "unit", element.getUnit(), -1); 5311 if (element.hasTerm()) 5312 composeCodeableConcept(t, "EligibilityResponse", "term", element.getTerm(), -1); 5313 for (int i = 0; i < element.getFinancial().size(); i++) 5314 composeEligibilityResponseBenefitComponent(t, "EligibilityResponse", "financial", element.getFinancial().get(i), i); 5315 } 5316 5317 protected void composeEligibilityResponseBenefitComponent(Complex parent, String parentType, String name, EligibilityResponse.BenefitComponent element, int index) { 5318 if (element == null) 5319 return; 5320 Complex t; 5321 if (Utilities.noString(parentType)) 5322 t = parent; 5323 else { 5324 t = parent.predicate("fhir:"+parentType+'.'+name); 5325 } 5326 composeBackboneElement(t, "financial", name, element, index); 5327 if (element.hasType()) 5328 composeCodeableConcept(t, "EligibilityResponse", "type", element.getType(), -1); 5329 if (element.hasAllowed()) 5330 composeType(t, "EligibilityResponse", "allowed", element.getAllowed(), -1); 5331 if (element.hasUsed()) 5332 composeType(t, "EligibilityResponse", "used", element.getUsed(), -1); 5333 } 5334 5335 protected void composeEligibilityResponseErrorsComponent(Complex parent, String parentType, String name, EligibilityResponse.ErrorsComponent element, int index) { 5336 if (element == null) 5337 return; 5338 Complex t; 5339 if (Utilities.noString(parentType)) 5340 t = parent; 5341 else { 5342 t = parent.predicate("fhir:"+parentType+'.'+name); 5343 } 5344 composeBackboneElement(t, "error", name, element, index); 5345 if (element.hasCode()) 5346 composeCodeableConcept(t, "EligibilityResponse", "code", element.getCode(), -1); 5347 } 5348 5349 protected void composeEncounter(Complex parent, String parentType, String name, Encounter element, int index) { 5350 if (element == null) 5351 return; 5352 Complex t; 5353 if (Utilities.noString(parentType)) 5354 t = parent; 5355 else { 5356 t = parent.predicate("fhir:"+parentType+'.'+name); 5357 } 5358 composeDomainResource(t, "Encounter", name, element, index); 5359 for (int i = 0; i < element.getIdentifier().size(); i++) 5360 composeIdentifier(t, "Encounter", "identifier", element.getIdentifier().get(i), i); 5361 if (element.hasStatusElement()) 5362 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 5363 for (int i = 0; i < element.getStatusHistory().size(); i++) 5364 composeEncounterStatusHistoryComponent(t, "Encounter", "statusHistory", element.getStatusHistory().get(i), i); 5365 if (element.hasClass_()) 5366 composeCoding(t, "Encounter", "class", element.getClass_(), -1); 5367 for (int i = 0; i < element.getClassHistory().size(); i++) 5368 composeEncounterClassHistoryComponent(t, "Encounter", "classHistory", element.getClassHistory().get(i), i); 5369 for (int i = 0; i < element.getType().size(); i++) 5370 composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i); 5371 if (element.hasPriority()) 5372 composeCodeableConcept(t, "Encounter", "priority", element.getPriority(), -1); 5373 if (element.hasSubject()) 5374 composeReference(t, "Encounter", "subject", element.getSubject(), -1); 5375 for (int i = 0; i < element.getEpisodeOfCare().size(); i++) 5376 composeReference(t, "Encounter", "episodeOfCare", element.getEpisodeOfCare().get(i), i); 5377 for (int i = 0; i < element.getIncomingReferral().size(); i++) 5378 composeReference(t, "Encounter", "incomingReferral", element.getIncomingReferral().get(i), i); 5379 for (int i = 0; i < element.getParticipant().size(); i++) 5380 composeEncounterEncounterParticipantComponent(t, "Encounter", "participant", element.getParticipant().get(i), i); 5381 if (element.hasAppointment()) 5382 composeReference(t, "Encounter", "appointment", element.getAppointment(), -1); 5383 if (element.hasPeriod()) 5384 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5385 if (element.hasLength()) 5386 composeDuration(t, "Encounter", "length", element.getLength(), -1); 5387 for (int i = 0; i < element.getReason().size(); i++) 5388 composeCodeableConcept(t, "Encounter", "reason", element.getReason().get(i), i); 5389 for (int i = 0; i < element.getDiagnosis().size(); i++) 5390 composeEncounterDiagnosisComponent(t, "Encounter", "diagnosis", element.getDiagnosis().get(i), i); 5391 for (int i = 0; i < element.getAccount().size(); i++) 5392 composeReference(t, "Encounter", "account", element.getAccount().get(i), i); 5393 if (element.hasHospitalization()) 5394 composeEncounterEncounterHospitalizationComponent(t, "Encounter", "hospitalization", element.getHospitalization(), -1); 5395 for (int i = 0; i < element.getLocation().size(); i++) 5396 composeEncounterEncounterLocationComponent(t, "Encounter", "location", element.getLocation().get(i), i); 5397 if (element.hasServiceProvider()) 5398 composeReference(t, "Encounter", "serviceProvider", element.getServiceProvider(), -1); 5399 if (element.hasPartOf()) 5400 composeReference(t, "Encounter", "partOf", element.getPartOf(), -1); 5401 } 5402 5403 protected void composeEncounterStatusHistoryComponent(Complex parent, String parentType, String name, Encounter.StatusHistoryComponent element, int index) { 5404 if (element == null) 5405 return; 5406 Complex t; 5407 if (Utilities.noString(parentType)) 5408 t = parent; 5409 else { 5410 t = parent.predicate("fhir:"+parentType+'.'+name); 5411 } 5412 composeBackboneElement(t, "statusHistory", name, element, index); 5413 if (element.hasStatusElement()) 5414 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 5415 if (element.hasPeriod()) 5416 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5417 } 5418 5419 protected void composeEncounterClassHistoryComponent(Complex parent, String parentType, String name, Encounter.ClassHistoryComponent element, int index) { 5420 if (element == null) 5421 return; 5422 Complex t; 5423 if (Utilities.noString(parentType)) 5424 t = parent; 5425 else { 5426 t = parent.predicate("fhir:"+parentType+'.'+name); 5427 } 5428 composeBackboneElement(t, "classHistory", name, element, index); 5429 if (element.hasClass_()) 5430 composeCoding(t, "Encounter", "class", element.getClass_(), -1); 5431 if (element.hasPeriod()) 5432 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5433 } 5434 5435 protected void composeEncounterEncounterParticipantComponent(Complex parent, String parentType, String name, Encounter.EncounterParticipantComponent element, int index) { 5436 if (element == null) 5437 return; 5438 Complex t; 5439 if (Utilities.noString(parentType)) 5440 t = parent; 5441 else { 5442 t = parent.predicate("fhir:"+parentType+'.'+name); 5443 } 5444 composeBackboneElement(t, "participant", name, element, index); 5445 for (int i = 0; i < element.getType().size(); i++) 5446 composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i); 5447 if (element.hasPeriod()) 5448 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5449 if (element.hasIndividual()) 5450 composeReference(t, "Encounter", "individual", element.getIndividual(), -1); 5451 } 5452 5453 protected void composeEncounterDiagnosisComponent(Complex parent, String parentType, String name, Encounter.DiagnosisComponent element, int index) { 5454 if (element == null) 5455 return; 5456 Complex t; 5457 if (Utilities.noString(parentType)) 5458 t = parent; 5459 else { 5460 t = parent.predicate("fhir:"+parentType+'.'+name); 5461 } 5462 composeBackboneElement(t, "diagnosis", name, element, index); 5463 if (element.hasCondition()) 5464 composeReference(t, "Encounter", "condition", element.getCondition(), -1); 5465 if (element.hasRole()) 5466 composeCodeableConcept(t, "Encounter", "role", element.getRole(), -1); 5467 if (element.hasRankElement()) 5468 composePositiveInt(t, "Encounter", "rank", element.getRankElement(), -1); 5469 } 5470 5471 protected void composeEncounterEncounterHospitalizationComponent(Complex parent, String parentType, String name, Encounter.EncounterHospitalizationComponent element, int index) { 5472 if (element == null) 5473 return; 5474 Complex t; 5475 if (Utilities.noString(parentType)) 5476 t = parent; 5477 else { 5478 t = parent.predicate("fhir:"+parentType+'.'+name); 5479 } 5480 composeBackboneElement(t, "hospitalization", name, element, index); 5481 if (element.hasPreAdmissionIdentifier()) 5482 composeIdentifier(t, "Encounter", "preAdmissionIdentifier", element.getPreAdmissionIdentifier(), -1); 5483 if (element.hasOrigin()) 5484 composeReference(t, "Encounter", "origin", element.getOrigin(), -1); 5485 if (element.hasAdmitSource()) 5486 composeCodeableConcept(t, "Encounter", "admitSource", element.getAdmitSource(), -1); 5487 if (element.hasReAdmission()) 5488 composeCodeableConcept(t, "Encounter", "reAdmission", element.getReAdmission(), -1); 5489 for (int i = 0; i < element.getDietPreference().size(); i++) 5490 composeCodeableConcept(t, "Encounter", "dietPreference", element.getDietPreference().get(i), i); 5491 for (int i = 0; i < element.getSpecialCourtesy().size(); i++) 5492 composeCodeableConcept(t, "Encounter", "specialCourtesy", element.getSpecialCourtesy().get(i), i); 5493 for (int i = 0; i < element.getSpecialArrangement().size(); i++) 5494 composeCodeableConcept(t, "Encounter", "specialArrangement", element.getSpecialArrangement().get(i), i); 5495 if (element.hasDestination()) 5496 composeReference(t, "Encounter", "destination", element.getDestination(), -1); 5497 if (element.hasDischargeDisposition()) 5498 composeCodeableConcept(t, "Encounter", "dischargeDisposition", element.getDischargeDisposition(), -1); 5499 } 5500 5501 protected void composeEncounterEncounterLocationComponent(Complex parent, String parentType, String name, Encounter.EncounterLocationComponent element, int index) { 5502 if (element == null) 5503 return; 5504 Complex t; 5505 if (Utilities.noString(parentType)) 5506 t = parent; 5507 else { 5508 t = parent.predicate("fhir:"+parentType+'.'+name); 5509 } 5510 composeBackboneElement(t, "location", name, element, index); 5511 if (element.hasLocation()) 5512 composeReference(t, "Encounter", "location", element.getLocation(), -1); 5513 if (element.hasStatusElement()) 5514 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 5515 if (element.hasPeriod()) 5516 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5517 } 5518 5519 protected void composeEndpoint(Complex parent, String parentType, String name, Endpoint element, int index) { 5520 if (element == null) 5521 return; 5522 Complex t; 5523 if (Utilities.noString(parentType)) 5524 t = parent; 5525 else { 5526 t = parent.predicate("fhir:"+parentType+'.'+name); 5527 } 5528 composeDomainResource(t, "Endpoint", name, element, index); 5529 for (int i = 0; i < element.getIdentifier().size(); i++) 5530 composeIdentifier(t, "Endpoint", "identifier", element.getIdentifier().get(i), i); 5531 if (element.hasStatusElement()) 5532 composeEnum(t, "Endpoint", "status", element.getStatusElement(), -1); 5533 if (element.hasConnectionType()) 5534 composeCoding(t, "Endpoint", "connectionType", element.getConnectionType(), -1); 5535 if (element.hasNameElement()) 5536 composeString(t, "Endpoint", "name", element.getNameElement(), -1); 5537 if (element.hasManagingOrganization()) 5538 composeReference(t, "Endpoint", "managingOrganization", element.getManagingOrganization(), -1); 5539 for (int i = 0; i < element.getContact().size(); i++) 5540 composeContactPoint(t, "Endpoint", "contact", element.getContact().get(i), i); 5541 if (element.hasPeriod()) 5542 composePeriod(t, "Endpoint", "period", element.getPeriod(), -1); 5543 for (int i = 0; i < element.getPayloadType().size(); i++) 5544 composeCodeableConcept(t, "Endpoint", "payloadType", element.getPayloadType().get(i), i); 5545 for (int i = 0; i < element.getPayloadMimeType().size(); i++) 5546 composeCode(t, "Endpoint", "payloadMimeType", element.getPayloadMimeType().get(i), i); 5547 if (element.hasAddressElement()) 5548 composeUri(t, "Endpoint", "address", element.getAddressElement(), -1); 5549 for (int i = 0; i < element.getHeader().size(); i++) 5550 composeString(t, "Endpoint", "header", element.getHeader().get(i), i); 5551 } 5552 5553 protected void composeEnrollmentRequest(Complex parent, String parentType, String name, EnrollmentRequest element, int index) { 5554 if (element == null) 5555 return; 5556 Complex t; 5557 if (Utilities.noString(parentType)) 5558 t = parent; 5559 else { 5560 t = parent.predicate("fhir:"+parentType+'.'+name); 5561 } 5562 composeDomainResource(t, "EnrollmentRequest", name, element, index); 5563 for (int i = 0; i < element.getIdentifier().size(); i++) 5564 composeIdentifier(t, "EnrollmentRequest", "identifier", element.getIdentifier().get(i), i); 5565 if (element.hasStatusElement()) 5566 composeEnum(t, "EnrollmentRequest", "status", element.getStatusElement(), -1); 5567 if (element.hasCreatedElement()) 5568 composeDateTime(t, "EnrollmentRequest", "created", element.getCreatedElement(), -1); 5569 if (element.hasInsurer()) 5570 composeReference(t, "EnrollmentRequest", "insurer", element.getInsurer(), -1); 5571 if (element.hasProvider()) 5572 composeReference(t, "EnrollmentRequest", "provider", element.getProvider(), -1); 5573 if (element.hasOrganization()) 5574 composeReference(t, "EnrollmentRequest", "organization", element.getOrganization(), -1); 5575 if (element.hasSubject()) 5576 composeReference(t, "EnrollmentRequest", "subject", element.getSubject(), -1); 5577 if (element.hasCoverage()) 5578 composeReference(t, "EnrollmentRequest", "coverage", element.getCoverage(), -1); 5579 } 5580 5581 protected void composeEnrollmentResponse(Complex parent, String parentType, String name, EnrollmentResponse element, int index) { 5582 if (element == null) 5583 return; 5584 Complex t; 5585 if (Utilities.noString(parentType)) 5586 t = parent; 5587 else { 5588 t = parent.predicate("fhir:"+parentType+'.'+name); 5589 } 5590 composeDomainResource(t, "EnrollmentResponse", name, element, index); 5591 for (int i = 0; i < element.getIdentifier().size(); i++) 5592 composeIdentifier(t, "EnrollmentResponse", "identifier", element.getIdentifier().get(i), i); 5593 if (element.hasStatusElement()) 5594 composeEnum(t, "EnrollmentResponse", "status", element.getStatusElement(), -1); 5595 if (element.hasRequest()) 5596 composeReference(t, "EnrollmentResponse", "request", element.getRequest(), -1); 5597 if (element.hasOutcome()) 5598 composeCodeableConcept(t, "EnrollmentResponse", "outcome", element.getOutcome(), -1); 5599 if (element.hasDispositionElement()) 5600 composeString(t, "EnrollmentResponse", "disposition", element.getDispositionElement(), -1); 5601 if (element.hasCreatedElement()) 5602 composeDateTime(t, "EnrollmentResponse", "created", element.getCreatedElement(), -1); 5603 if (element.hasOrganization()) 5604 composeReference(t, "EnrollmentResponse", "organization", element.getOrganization(), -1); 5605 if (element.hasRequestProvider()) 5606 composeReference(t, "EnrollmentResponse", "requestProvider", element.getRequestProvider(), -1); 5607 if (element.hasRequestOrganization()) 5608 composeReference(t, "EnrollmentResponse", "requestOrganization", element.getRequestOrganization(), -1); 5609 } 5610 5611 protected void composeEpisodeOfCare(Complex parent, String parentType, String name, EpisodeOfCare element, int index) { 5612 if (element == null) 5613 return; 5614 Complex t; 5615 if (Utilities.noString(parentType)) 5616 t = parent; 5617 else { 5618 t = parent.predicate("fhir:"+parentType+'.'+name); 5619 } 5620 composeDomainResource(t, "EpisodeOfCare", name, element, index); 5621 for (int i = 0; i < element.getIdentifier().size(); i++) 5622 composeIdentifier(t, "EpisodeOfCare", "identifier", element.getIdentifier().get(i), i); 5623 if (element.hasStatusElement()) 5624 composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1); 5625 for (int i = 0; i < element.getStatusHistory().size(); i++) 5626 composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(t, "EpisodeOfCare", "statusHistory", element.getStatusHistory().get(i), i); 5627 for (int i = 0; i < element.getType().size(); i++) 5628 composeCodeableConcept(t, "EpisodeOfCare", "type", element.getType().get(i), i); 5629 for (int i = 0; i < element.getDiagnosis().size(); i++) 5630 composeEpisodeOfCareDiagnosisComponent(t, "EpisodeOfCare", "diagnosis", element.getDiagnosis().get(i), i); 5631 if (element.hasPatient()) 5632 composeReference(t, "EpisodeOfCare", "patient", element.getPatient(), -1); 5633 if (element.hasManagingOrganization()) 5634 composeReference(t, "EpisodeOfCare", "managingOrganization", element.getManagingOrganization(), -1); 5635 if (element.hasPeriod()) 5636 composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1); 5637 for (int i = 0; i < element.getReferralRequest().size(); i++) 5638 composeReference(t, "EpisodeOfCare", "referralRequest", element.getReferralRequest().get(i), i); 5639 if (element.hasCareManager()) 5640 composeReference(t, "EpisodeOfCare", "careManager", element.getCareManager(), -1); 5641 for (int i = 0; i < element.getTeam().size(); i++) 5642 composeReference(t, "EpisodeOfCare", "team", element.getTeam().get(i), i); 5643 for (int i = 0; i < element.getAccount().size(); i++) 5644 composeReference(t, "EpisodeOfCare", "account", element.getAccount().get(i), i); 5645 } 5646 5647 protected void composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(Complex parent, String parentType, String name, EpisodeOfCare.EpisodeOfCareStatusHistoryComponent element, int index) { 5648 if (element == null) 5649 return; 5650 Complex t; 5651 if (Utilities.noString(parentType)) 5652 t = parent; 5653 else { 5654 t = parent.predicate("fhir:"+parentType+'.'+name); 5655 } 5656 composeBackboneElement(t, "statusHistory", name, element, index); 5657 if (element.hasStatusElement()) 5658 composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1); 5659 if (element.hasPeriod()) 5660 composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1); 5661 } 5662 5663 protected void composeEpisodeOfCareDiagnosisComponent(Complex parent, String parentType, String name, EpisodeOfCare.DiagnosisComponent element, int index) { 5664 if (element == null) 5665 return; 5666 Complex t; 5667 if (Utilities.noString(parentType)) 5668 t = parent; 5669 else { 5670 t = parent.predicate("fhir:"+parentType+'.'+name); 5671 } 5672 composeBackboneElement(t, "diagnosis", name, element, index); 5673 if (element.hasCondition()) 5674 composeReference(t, "EpisodeOfCare", "condition", element.getCondition(), -1); 5675 if (element.hasRole()) 5676 composeCodeableConcept(t, "EpisodeOfCare", "role", element.getRole(), -1); 5677 if (element.hasRankElement()) 5678 composePositiveInt(t, "EpisodeOfCare", "rank", element.getRankElement(), -1); 5679 } 5680 5681 protected void composeExpansionProfile(Complex parent, String parentType, String name, ExpansionProfile element, int index) { 5682 if (element == null) 5683 return; 5684 Complex t; 5685 if (Utilities.noString(parentType)) 5686 t = parent; 5687 else { 5688 t = parent.predicate("fhir:"+parentType+'.'+name); 5689 } 5690 composeDomainResource(t, "ExpansionProfile", name, element, index); 5691 if (element.hasUrlElement()) 5692 composeUri(t, "ExpansionProfile", "url", element.getUrlElement(), -1); 5693 if (element.hasIdentifier()) 5694 composeIdentifier(t, "ExpansionProfile", "identifier", element.getIdentifier(), -1); 5695 if (element.hasVersionElement()) 5696 composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1); 5697 if (element.hasNameElement()) 5698 composeString(t, "ExpansionProfile", "name", element.getNameElement(), -1); 5699 if (element.hasStatusElement()) 5700 composeEnum(t, "ExpansionProfile", "status", element.getStatusElement(), -1); 5701 if (element.hasExperimentalElement()) 5702 composeBoolean(t, "ExpansionProfile", "experimental", element.getExperimentalElement(), -1); 5703 if (element.hasDateElement()) 5704 composeDateTime(t, "ExpansionProfile", "date", element.getDateElement(), -1); 5705 if (element.hasPublisherElement()) 5706 composeString(t, "ExpansionProfile", "publisher", element.getPublisherElement(), -1); 5707 for (int i = 0; i < element.getContact().size(); i++) 5708 composeContactDetail(t, "ExpansionProfile", "contact", element.getContact().get(i), i); 5709 if (element.hasDescriptionElement()) 5710 composeMarkdown(t, "ExpansionProfile", "description", element.getDescriptionElement(), -1); 5711 for (int i = 0; i < element.getUseContext().size(); i++) 5712 composeUsageContext(t, "ExpansionProfile", "useContext", element.getUseContext().get(i), i); 5713 for (int i = 0; i < element.getJurisdiction().size(); i++) 5714 composeCodeableConcept(t, "ExpansionProfile", "jurisdiction", element.getJurisdiction().get(i), i); 5715 for (int i = 0; i < element.getFixedVersion().size(); i++) 5716 composeExpansionProfileExpansionProfileFixedVersionComponent(t, "ExpansionProfile", "fixedVersion", element.getFixedVersion().get(i), i); 5717 if (element.hasExcludedSystem()) 5718 composeExpansionProfileExpansionProfileExcludedSystemComponent(t, "ExpansionProfile", "excludedSystem", element.getExcludedSystem(), -1); 5719 if (element.hasIncludeDesignationsElement()) 5720 composeBoolean(t, "ExpansionProfile", "includeDesignations", element.getIncludeDesignationsElement(), -1); 5721 if (element.hasDesignation()) 5722 composeExpansionProfileExpansionProfileDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation(), -1); 5723 if (element.hasIncludeDefinitionElement()) 5724 composeBoolean(t, "ExpansionProfile", "includeDefinition", element.getIncludeDefinitionElement(), -1); 5725 if (element.hasActiveOnlyElement()) 5726 composeBoolean(t, "ExpansionProfile", "activeOnly", element.getActiveOnlyElement(), -1); 5727 if (element.hasExcludeNestedElement()) 5728 composeBoolean(t, "ExpansionProfile", "excludeNested", element.getExcludeNestedElement(), -1); 5729 if (element.hasExcludeNotForUIElement()) 5730 composeBoolean(t, "ExpansionProfile", "excludeNotForUI", element.getExcludeNotForUIElement(), -1); 5731 if (element.hasExcludePostCoordinatedElement()) 5732 composeBoolean(t, "ExpansionProfile", "excludePostCoordinated", element.getExcludePostCoordinatedElement(), -1); 5733 if (element.hasDisplayLanguageElement()) 5734 composeCode(t, "ExpansionProfile", "displayLanguage", element.getDisplayLanguageElement(), -1); 5735 if (element.hasLimitedExpansionElement()) 5736 composeBoolean(t, "ExpansionProfile", "limitedExpansion", element.getLimitedExpansionElement(), -1); 5737 } 5738 5739 protected void composeExpansionProfileExpansionProfileFixedVersionComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileFixedVersionComponent element, int index) { 5740 if (element == null) 5741 return; 5742 Complex t; 5743 if (Utilities.noString(parentType)) 5744 t = parent; 5745 else { 5746 t = parent.predicate("fhir:"+parentType+'.'+name); 5747 } 5748 composeBackboneElement(t, "fixedVersion", name, element, index); 5749 if (element.hasSystemElement()) 5750 composeUri(t, "ExpansionProfile", "system", element.getSystemElement(), -1); 5751 if (element.hasVersionElement()) 5752 composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1); 5753 if (element.hasModeElement()) 5754 composeEnum(t, "ExpansionProfile", "mode", element.getModeElement(), -1); 5755 } 5756 5757 protected void composeExpansionProfileExpansionProfileExcludedSystemComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileExcludedSystemComponent element, int index) { 5758 if (element == null) 5759 return; 5760 Complex t; 5761 if (Utilities.noString(parentType)) 5762 t = parent; 5763 else { 5764 t = parent.predicate("fhir:"+parentType+'.'+name); 5765 } 5766 composeBackboneElement(t, "excludedSystem", name, element, index); 5767 if (element.hasSystemElement()) 5768 composeUri(t, "ExpansionProfile", "system", element.getSystemElement(), -1); 5769 if (element.hasVersionElement()) 5770 composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1); 5771 } 5772 5773 protected void composeExpansionProfileExpansionProfileDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileDesignationComponent element, int index) { 5774 if (element == null) 5775 return; 5776 Complex t; 5777 if (Utilities.noString(parentType)) 5778 t = parent; 5779 else { 5780 t = parent.predicate("fhir:"+parentType+'.'+name); 5781 } 5782 composeBackboneElement(t, "designation", name, element, index); 5783 if (element.hasInclude()) 5784 composeExpansionProfileDesignationIncludeComponent(t, "ExpansionProfile", "include", element.getInclude(), -1); 5785 if (element.hasExclude()) 5786 composeExpansionProfileDesignationExcludeComponent(t, "ExpansionProfile", "exclude", element.getExclude(), -1); 5787 } 5788 5789 protected void composeExpansionProfileDesignationIncludeComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationIncludeComponent element, int index) { 5790 if (element == null) 5791 return; 5792 Complex t; 5793 if (Utilities.noString(parentType)) 5794 t = parent; 5795 else { 5796 t = parent.predicate("fhir:"+parentType+'.'+name); 5797 } 5798 composeBackboneElement(t, "include", name, element, index); 5799 for (int i = 0; i < element.getDesignation().size(); i++) 5800 composeExpansionProfileDesignationIncludeDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation().get(i), i); 5801 } 5802 5803 protected void composeExpansionProfileDesignationIncludeDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationIncludeDesignationComponent element, int index) { 5804 if (element == null) 5805 return; 5806 Complex t; 5807 if (Utilities.noString(parentType)) 5808 t = parent; 5809 else { 5810 t = parent.predicate("fhir:"+parentType+'.'+name); 5811 } 5812 composeBackboneElement(t, "designation", name, element, index); 5813 if (element.hasLanguageElement()) 5814 composeCode(t, "ExpansionProfile", "language", element.getLanguageElement(), -1); 5815 if (element.hasUse()) 5816 composeCoding(t, "ExpansionProfile", "use", element.getUse(), -1); 5817 } 5818 5819 protected void composeExpansionProfileDesignationExcludeComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationExcludeComponent element, int index) { 5820 if (element == null) 5821 return; 5822 Complex t; 5823 if (Utilities.noString(parentType)) 5824 t = parent; 5825 else { 5826 t = parent.predicate("fhir:"+parentType+'.'+name); 5827 } 5828 composeBackboneElement(t, "exclude", name, element, index); 5829 for (int i = 0; i < element.getDesignation().size(); i++) 5830 composeExpansionProfileDesignationExcludeDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation().get(i), i); 5831 } 5832 5833 protected void composeExpansionProfileDesignationExcludeDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationExcludeDesignationComponent element, int index) { 5834 if (element == null) 5835 return; 5836 Complex t; 5837 if (Utilities.noString(parentType)) 5838 t = parent; 5839 else { 5840 t = parent.predicate("fhir:"+parentType+'.'+name); 5841 } 5842 composeBackboneElement(t, "designation", name, element, index); 5843 if (element.hasLanguageElement()) 5844 composeCode(t, "ExpansionProfile", "language", element.getLanguageElement(), -1); 5845 if (element.hasUse()) 5846 composeCoding(t, "ExpansionProfile", "use", element.getUse(), -1); 5847 } 5848 5849 protected void composeExplanationOfBenefit(Complex parent, String parentType, String name, ExplanationOfBenefit element, int index) { 5850 if (element == null) 5851 return; 5852 Complex t; 5853 if (Utilities.noString(parentType)) 5854 t = parent; 5855 else { 5856 t = parent.predicate("fhir:"+parentType+'.'+name); 5857 } 5858 composeDomainResource(t, "ExplanationOfBenefit", name, element, index); 5859 for (int i = 0; i < element.getIdentifier().size(); i++) 5860 composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier().get(i), i); 5861 if (element.hasStatusElement()) 5862 composeEnum(t, "ExplanationOfBenefit", "status", element.getStatusElement(), -1); 5863 if (element.hasType()) 5864 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 5865 for (int i = 0; i < element.getSubType().size(); i++) 5866 composeCodeableConcept(t, "ExplanationOfBenefit", "subType", element.getSubType().get(i), i); 5867 if (element.hasPatient()) 5868 composeReference(t, "ExplanationOfBenefit", "patient", element.getPatient(), -1); 5869 if (element.hasBillablePeriod()) 5870 composePeriod(t, "ExplanationOfBenefit", "billablePeriod", element.getBillablePeriod(), -1); 5871 if (element.hasCreatedElement()) 5872 composeDateTime(t, "ExplanationOfBenefit", "created", element.getCreatedElement(), -1); 5873 if (element.hasEnterer()) 5874 composeReference(t, "ExplanationOfBenefit", "enterer", element.getEnterer(), -1); 5875 if (element.hasInsurer()) 5876 composeReference(t, "ExplanationOfBenefit", "insurer", element.getInsurer(), -1); 5877 if (element.hasProvider()) 5878 composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1); 5879 if (element.hasOrganization()) 5880 composeReference(t, "ExplanationOfBenefit", "organization", element.getOrganization(), -1); 5881 if (element.hasReferral()) 5882 composeReference(t, "ExplanationOfBenefit", "referral", element.getReferral(), -1); 5883 if (element.hasFacility()) 5884 composeReference(t, "ExplanationOfBenefit", "facility", element.getFacility(), -1); 5885 if (element.hasClaim()) 5886 composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1); 5887 if (element.hasClaimResponse()) 5888 composeReference(t, "ExplanationOfBenefit", "claimResponse", element.getClaimResponse(), -1); 5889 if (element.hasOutcome()) 5890 composeCodeableConcept(t, "ExplanationOfBenefit", "outcome", element.getOutcome(), -1); 5891 if (element.hasDispositionElement()) 5892 composeString(t, "ExplanationOfBenefit", "disposition", element.getDispositionElement(), -1); 5893 for (int i = 0; i < element.getRelated().size(); i++) 5894 composeExplanationOfBenefitRelatedClaimComponent(t, "ExplanationOfBenefit", "related", element.getRelated().get(i), i); 5895 if (element.hasPrescription()) 5896 composeReference(t, "ExplanationOfBenefit", "prescription", element.getPrescription(), -1); 5897 if (element.hasOriginalPrescription()) 5898 composeReference(t, "ExplanationOfBenefit", "originalPrescription", element.getOriginalPrescription(), -1); 5899 if (element.hasPayee()) 5900 composeExplanationOfBenefitPayeeComponent(t, "ExplanationOfBenefit", "payee", element.getPayee(), -1); 5901 for (int i = 0; i < element.getInformation().size(); i++) 5902 composeExplanationOfBenefitSupportingInformationComponent(t, "ExplanationOfBenefit", "information", element.getInformation().get(i), i); 5903 for (int i = 0; i < element.getCareTeam().size(); i++) 5904 composeExplanationOfBenefitCareTeamComponent(t, "ExplanationOfBenefit", "careTeam", element.getCareTeam().get(i), i); 5905 for (int i = 0; i < element.getDiagnosis().size(); i++) 5906 composeExplanationOfBenefitDiagnosisComponent(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis().get(i), i); 5907 for (int i = 0; i < element.getProcedure().size(); i++) 5908 composeExplanationOfBenefitProcedureComponent(t, "ExplanationOfBenefit", "procedure", element.getProcedure().get(i), i); 5909 if (element.hasPrecedenceElement()) 5910 composePositiveInt(t, "ExplanationOfBenefit", "precedence", element.getPrecedenceElement(), -1); 5911 if (element.hasInsurance()) 5912 composeExplanationOfBenefitInsuranceComponent(t, "ExplanationOfBenefit", "insurance", element.getInsurance(), -1); 5913 if (element.hasAccident()) 5914 composeExplanationOfBenefitAccidentComponent(t, "ExplanationOfBenefit", "accident", element.getAccident(), -1); 5915 if (element.hasEmploymentImpacted()) 5916 composePeriod(t, "ExplanationOfBenefit", "employmentImpacted", element.getEmploymentImpacted(), -1); 5917 if (element.hasHospitalization()) 5918 composePeriod(t, "ExplanationOfBenefit", "hospitalization", element.getHospitalization(), -1); 5919 for (int i = 0; i < element.getItem().size(); i++) 5920 composeExplanationOfBenefitItemComponent(t, "ExplanationOfBenefit", "item", element.getItem().get(i), i); 5921 for (int i = 0; i < element.getAddItem().size(); i++) 5922 composeExplanationOfBenefitAddedItemComponent(t, "ExplanationOfBenefit", "addItem", element.getAddItem().get(i), i); 5923 if (element.hasTotalCost()) 5924 composeMoney(t, "ExplanationOfBenefit", "totalCost", element.getTotalCost(), -1); 5925 if (element.hasUnallocDeductable()) 5926 composeMoney(t, "ExplanationOfBenefit", "unallocDeductable", element.getUnallocDeductable(), -1); 5927 if (element.hasTotalBenefit()) 5928 composeMoney(t, "ExplanationOfBenefit", "totalBenefit", element.getTotalBenefit(), -1); 5929 if (element.hasPayment()) 5930 composeExplanationOfBenefitPaymentComponent(t, "ExplanationOfBenefit", "payment", element.getPayment(), -1); 5931 if (element.hasForm()) 5932 composeCodeableConcept(t, "ExplanationOfBenefit", "form", element.getForm(), -1); 5933 for (int i = 0; i < element.getProcessNote().size(); i++) 5934 composeExplanationOfBenefitNoteComponent(t, "ExplanationOfBenefit", "processNote", element.getProcessNote().get(i), i); 5935 for (int i = 0; i < element.getBenefitBalance().size(); i++) 5936 composeExplanationOfBenefitBenefitBalanceComponent(t, "ExplanationOfBenefit", "benefitBalance", element.getBenefitBalance().get(i), i); 5937 } 5938 5939 protected void composeExplanationOfBenefitRelatedClaimComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.RelatedClaimComponent element, int index) { 5940 if (element == null) 5941 return; 5942 Complex t; 5943 if (Utilities.noString(parentType)) 5944 t = parent; 5945 else { 5946 t = parent.predicate("fhir:"+parentType+'.'+name); 5947 } 5948 composeBackboneElement(t, "related", name, element, index); 5949 if (element.hasClaim()) 5950 composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1); 5951 if (element.hasRelationship()) 5952 composeCodeableConcept(t, "ExplanationOfBenefit", "relationship", element.getRelationship(), -1); 5953 if (element.hasReference()) 5954 composeIdentifier(t, "ExplanationOfBenefit", "reference", element.getReference(), -1); 5955 } 5956 5957 protected void composeExplanationOfBenefitPayeeComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PayeeComponent element, int index) { 5958 if (element == null) 5959 return; 5960 Complex t; 5961 if (Utilities.noString(parentType)) 5962 t = parent; 5963 else { 5964 t = parent.predicate("fhir:"+parentType+'.'+name); 5965 } 5966 composeBackboneElement(t, "payee", name, element, index); 5967 if (element.hasType()) 5968 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 5969 if (element.hasResourceType()) 5970 composeCodeableConcept(t, "ExplanationOfBenefit", "resourceType", element.getResourceType(), -1); 5971 if (element.hasParty()) 5972 composeReference(t, "ExplanationOfBenefit", "party", element.getParty(), -1); 5973 } 5974 5975 protected void composeExplanationOfBenefitSupportingInformationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SupportingInformationComponent element, int index) { 5976 if (element == null) 5977 return; 5978 Complex t; 5979 if (Utilities.noString(parentType)) 5980 t = parent; 5981 else { 5982 t = parent.predicate("fhir:"+parentType+'.'+name); 5983 } 5984 composeBackboneElement(t, "information", name, element, index); 5985 if (element.hasSequenceElement()) 5986 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 5987 if (element.hasCategory()) 5988 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 5989 if (element.hasCode()) 5990 composeCodeableConcept(t, "ExplanationOfBenefit", "code", element.getCode(), -1); 5991 if (element.hasTiming()) 5992 composeType(t, "ExplanationOfBenefit", "timing", element.getTiming(), -1); 5993 if (element.hasValue()) 5994 composeType(t, "ExplanationOfBenefit", "value", element.getValue(), -1); 5995 if (element.hasReason()) 5996 composeCoding(t, "ExplanationOfBenefit", "reason", element.getReason(), -1); 5997 } 5998 5999 protected void composeExplanationOfBenefitCareTeamComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.CareTeamComponent element, int index) { 6000 if (element == null) 6001 return; 6002 Complex t; 6003 if (Utilities.noString(parentType)) 6004 t = parent; 6005 else { 6006 t = parent.predicate("fhir:"+parentType+'.'+name); 6007 } 6008 composeBackboneElement(t, "careTeam", name, element, index); 6009 if (element.hasSequenceElement()) 6010 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6011 if (element.hasProvider()) 6012 composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1); 6013 if (element.hasResponsibleElement()) 6014 composeBoolean(t, "ExplanationOfBenefit", "responsible", element.getResponsibleElement(), -1); 6015 if (element.hasRole()) 6016 composeCodeableConcept(t, "ExplanationOfBenefit", "role", element.getRole(), -1); 6017 if (element.hasQualification()) 6018 composeCodeableConcept(t, "ExplanationOfBenefit", "qualification", element.getQualification(), -1); 6019 } 6020 6021 protected void composeExplanationOfBenefitDiagnosisComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DiagnosisComponent element, int index) { 6022 if (element == null) 6023 return; 6024 Complex t; 6025 if (Utilities.noString(parentType)) 6026 t = parent; 6027 else { 6028 t = parent.predicate("fhir:"+parentType+'.'+name); 6029 } 6030 composeBackboneElement(t, "diagnosis", name, element, index); 6031 if (element.hasSequenceElement()) 6032 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6033 if (element.hasDiagnosis()) 6034 composeType(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis(), -1); 6035 for (int i = 0; i < element.getType().size(); i++) 6036 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType().get(i), i); 6037 if (element.hasPackageCode()) 6038 composeCodeableConcept(t, "ExplanationOfBenefit", "packageCode", element.getPackageCode(), -1); 6039 } 6040 6041 protected void composeExplanationOfBenefitProcedureComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ProcedureComponent 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, "procedure", name, element, index); 6051 if (element.hasSequenceElement()) 6052 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6053 if (element.hasDateElement()) 6054 composeDateTime(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1); 6055 if (element.hasProcedure()) 6056 composeType(t, "ExplanationOfBenefit", "procedure", element.getProcedure(), -1); 6057 } 6058 6059 protected void composeExplanationOfBenefitInsuranceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.InsuranceComponent element, int index) { 6060 if (element == null) 6061 return; 6062 Complex t; 6063 if (Utilities.noString(parentType)) 6064 t = parent; 6065 else { 6066 t = parent.predicate("fhir:"+parentType+'.'+name); 6067 } 6068 composeBackboneElement(t, "insurance", name, element, index); 6069 if (element.hasCoverage()) 6070 composeReference(t, "ExplanationOfBenefit", "coverage", element.getCoverage(), -1); 6071 for (int i = 0; i < element.getPreAuthRef().size(); i++) 6072 composeString(t, "ExplanationOfBenefit", "preAuthRef", element.getPreAuthRef().get(i), i); 6073 } 6074 6075 protected void composeExplanationOfBenefitAccidentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AccidentComponent element, int index) { 6076 if (element == null) 6077 return; 6078 Complex t; 6079 if (Utilities.noString(parentType)) 6080 t = parent; 6081 else { 6082 t = parent.predicate("fhir:"+parentType+'.'+name); 6083 } 6084 composeBackboneElement(t, "accident", name, element, index); 6085 if (element.hasDateElement()) 6086 composeDate(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1); 6087 if (element.hasType()) 6088 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6089 if (element.hasLocation()) 6090 composeType(t, "ExplanationOfBenefit", "location", element.getLocation(), -1); 6091 } 6092 6093 protected void composeExplanationOfBenefitItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ItemComponent element, int index) { 6094 if (element == null) 6095 return; 6096 Complex t; 6097 if (Utilities.noString(parentType)) 6098 t = parent; 6099 else { 6100 t = parent.predicate("fhir:"+parentType+'.'+name); 6101 } 6102 composeBackboneElement(t, "item", name, element, index); 6103 if (element.hasSequenceElement()) 6104 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6105 for (int i = 0; i < element.getCareTeamLinkId().size(); i++) 6106 composePositiveInt(t, "ExplanationOfBenefit", "careTeamLinkId", element.getCareTeamLinkId().get(i), i); 6107 for (int i = 0; i < element.getDiagnosisLinkId().size(); i++) 6108 composePositiveInt(t, "ExplanationOfBenefit", "diagnosisLinkId", element.getDiagnosisLinkId().get(i), i); 6109 for (int i = 0; i < element.getProcedureLinkId().size(); i++) 6110 composePositiveInt(t, "ExplanationOfBenefit", "procedureLinkId", element.getProcedureLinkId().get(i), i); 6111 for (int i = 0; i < element.getInformationLinkId().size(); i++) 6112 composePositiveInt(t, "ExplanationOfBenefit", "informationLinkId", element.getInformationLinkId().get(i), i); 6113 if (element.hasRevenue()) 6114 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6115 if (element.hasCategory()) 6116 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6117 if (element.hasService()) 6118 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6119 for (int i = 0; i < element.getModifier().size(); i++) 6120 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6121 for (int i = 0; i < element.getProgramCode().size(); i++) 6122 composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 6123 if (element.hasServiced()) 6124 composeType(t, "ExplanationOfBenefit", "serviced", element.getServiced(), -1); 6125 if (element.hasLocation()) 6126 composeType(t, "ExplanationOfBenefit", "location", element.getLocation(), -1); 6127 if (element.hasQuantity()) 6128 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 6129 if (element.hasUnitPrice()) 6130 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 6131 if (element.hasFactorElement()) 6132 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 6133 if (element.hasNet()) 6134 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 6135 for (int i = 0; i < element.getUdi().size(); i++) 6136 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 6137 if (element.hasBodySite()) 6138 composeCodeableConcept(t, "ExplanationOfBenefit", "bodySite", element.getBodySite(), -1); 6139 for (int i = 0; i < element.getSubSite().size(); i++) 6140 composeCodeableConcept(t, "ExplanationOfBenefit", "subSite", element.getSubSite().get(i), i); 6141 for (int i = 0; i < element.getEncounter().size(); i++) 6142 composeReference(t, "ExplanationOfBenefit", "encounter", element.getEncounter().get(i), i); 6143 for (int i = 0; i < element.getNoteNumber().size(); i++) 6144 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6145 for (int i = 0; i < element.getAdjudication().size(); i++) 6146 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6147 for (int i = 0; i < element.getDetail().size(); i++) 6148 composeExplanationOfBenefitDetailComponent(t, "ExplanationOfBenefit", "detail", element.getDetail().get(i), i); 6149 } 6150 6151 protected void composeExplanationOfBenefitAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AdjudicationComponent element, int index) { 6152 if (element == null) 6153 return; 6154 Complex t; 6155 if (Utilities.noString(parentType)) 6156 t = parent; 6157 else { 6158 t = parent.predicate("fhir:"+parentType+'.'+name); 6159 } 6160 composeBackboneElement(t, "adjudication", name, element, index); 6161 if (element.hasCategory()) 6162 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6163 if (element.hasReason()) 6164 composeCodeableConcept(t, "ExplanationOfBenefit", "reason", element.getReason(), -1); 6165 if (element.hasAmount()) 6166 composeMoney(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1); 6167 if (element.hasValueElement()) 6168 composeDecimal(t, "ExplanationOfBenefit", "value", element.getValueElement(), -1); 6169 } 6170 6171 protected void composeExplanationOfBenefitDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DetailComponent 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, "detail", name, element, index); 6181 if (element.hasSequenceElement()) 6182 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6183 if (element.hasType()) 6184 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6185 if (element.hasRevenue()) 6186 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6187 if (element.hasCategory()) 6188 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6189 if (element.hasService()) 6190 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6191 for (int i = 0; i < element.getModifier().size(); i++) 6192 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6193 for (int i = 0; i < element.getProgramCode().size(); i++) 6194 composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 6195 if (element.hasQuantity()) 6196 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 6197 if (element.hasUnitPrice()) 6198 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 6199 if (element.hasFactorElement()) 6200 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 6201 if (element.hasNet()) 6202 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 6203 for (int i = 0; i < element.getUdi().size(); i++) 6204 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 6205 for (int i = 0; i < element.getNoteNumber().size(); i++) 6206 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6207 for (int i = 0; i < element.getAdjudication().size(); i++) 6208 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6209 for (int i = 0; i < element.getSubDetail().size(); i++) 6210 composeExplanationOfBenefitSubDetailComponent(t, "ExplanationOfBenefit", "subDetail", element.getSubDetail().get(i), i); 6211 } 6212 6213 protected void composeExplanationOfBenefitSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SubDetailComponent element, int index) { 6214 if (element == null) 6215 return; 6216 Complex t; 6217 if (Utilities.noString(parentType)) 6218 t = parent; 6219 else { 6220 t = parent.predicate("fhir:"+parentType+'.'+name); 6221 } 6222 composeBackboneElement(t, "subDetail", name, element, index); 6223 if (element.hasSequenceElement()) 6224 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6225 if (element.hasType()) 6226 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6227 if (element.hasRevenue()) 6228 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6229 if (element.hasCategory()) 6230 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6231 if (element.hasService()) 6232 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6233 for (int i = 0; i < element.getModifier().size(); i++) 6234 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6235 for (int i = 0; i < element.getProgramCode().size(); i++) 6236 composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 6237 if (element.hasQuantity()) 6238 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 6239 if (element.hasUnitPrice()) 6240 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 6241 if (element.hasFactorElement()) 6242 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 6243 if (element.hasNet()) 6244 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 6245 for (int i = 0; i < element.getUdi().size(); i++) 6246 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 6247 for (int i = 0; i < element.getNoteNumber().size(); i++) 6248 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6249 for (int i = 0; i < element.getAdjudication().size(); i++) 6250 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6251 } 6252 6253 protected void composeExplanationOfBenefitAddedItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemComponent element, int index) { 6254 if (element == null) 6255 return; 6256 Complex t; 6257 if (Utilities.noString(parentType)) 6258 t = parent; 6259 else { 6260 t = parent.predicate("fhir:"+parentType+'.'+name); 6261 } 6262 composeBackboneElement(t, "addItem", name, element, index); 6263 for (int i = 0; i < element.getSequenceLinkId().size(); i++) 6264 composePositiveInt(t, "ExplanationOfBenefit", "sequenceLinkId", element.getSequenceLinkId().get(i), i); 6265 if (element.hasRevenue()) 6266 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6267 if (element.hasCategory()) 6268 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6269 if (element.hasService()) 6270 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6271 for (int i = 0; i < element.getModifier().size(); i++) 6272 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6273 if (element.hasFee()) 6274 composeMoney(t, "ExplanationOfBenefit", "fee", element.getFee(), -1); 6275 for (int i = 0; i < element.getNoteNumber().size(); i++) 6276 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6277 for (int i = 0; i < element.getAdjudication().size(); i++) 6278 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6279 for (int i = 0; i < element.getDetail().size(); i++) 6280 composeExplanationOfBenefitAddedItemsDetailComponent(t, "ExplanationOfBenefit", "detail", element.getDetail().get(i), i); 6281 } 6282 6283 protected void composeExplanationOfBenefitAddedItemsDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemsDetailComponent element, int index) { 6284 if (element == null) 6285 return; 6286 Complex t; 6287 if (Utilities.noString(parentType)) 6288 t = parent; 6289 else { 6290 t = parent.predicate("fhir:"+parentType+'.'+name); 6291 } 6292 composeBackboneElement(t, "detail", name, element, index); 6293 if (element.hasRevenue()) 6294 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6295 if (element.hasCategory()) 6296 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6297 if (element.hasService()) 6298 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6299 for (int i = 0; i < element.getModifier().size(); i++) 6300 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6301 if (element.hasFee()) 6302 composeMoney(t, "ExplanationOfBenefit", "fee", element.getFee(), -1); 6303 for (int i = 0; i < element.getNoteNumber().size(); i++) 6304 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6305 for (int i = 0; i < element.getAdjudication().size(); i++) 6306 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6307 } 6308 6309 protected void composeExplanationOfBenefitPaymentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PaymentComponent element, int index) { 6310 if (element == null) 6311 return; 6312 Complex t; 6313 if (Utilities.noString(parentType)) 6314 t = parent; 6315 else { 6316 t = parent.predicate("fhir:"+parentType+'.'+name); 6317 } 6318 composeBackboneElement(t, "payment", name, element, index); 6319 if (element.hasType()) 6320 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6321 if (element.hasAdjustment()) 6322 composeMoney(t, "ExplanationOfBenefit", "adjustment", element.getAdjustment(), -1); 6323 if (element.hasAdjustmentReason()) 6324 composeCodeableConcept(t, "ExplanationOfBenefit", "adjustmentReason", element.getAdjustmentReason(), -1); 6325 if (element.hasDateElement()) 6326 composeDate(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1); 6327 if (element.hasAmount()) 6328 composeMoney(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1); 6329 if (element.hasIdentifier()) 6330 composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier(), -1); 6331 } 6332 6333 protected void composeExplanationOfBenefitNoteComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.NoteComponent element, int index) { 6334 if (element == null) 6335 return; 6336 Complex t; 6337 if (Utilities.noString(parentType)) 6338 t = parent; 6339 else { 6340 t = parent.predicate("fhir:"+parentType+'.'+name); 6341 } 6342 composeBackboneElement(t, "processNote", name, element, index); 6343 if (element.hasNumberElement()) 6344 composePositiveInt(t, "ExplanationOfBenefit", "number", element.getNumberElement(), -1); 6345 if (element.hasType()) 6346 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6347 if (element.hasTextElement()) 6348 composeString(t, "ExplanationOfBenefit", "text", element.getTextElement(), -1); 6349 if (element.hasLanguage()) 6350 composeCodeableConcept(t, "ExplanationOfBenefit", "language", element.getLanguage(), -1); 6351 } 6352 6353 protected void composeExplanationOfBenefitBenefitBalanceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitBalanceComponent 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, "benefitBalance", name, element, index); 6363 if (element.hasCategory()) 6364 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6365 if (element.hasSubCategory()) 6366 composeCodeableConcept(t, "ExplanationOfBenefit", "subCategory", element.getSubCategory(), -1); 6367 if (element.hasExcludedElement()) 6368 composeBoolean(t, "ExplanationOfBenefit", "excluded", element.getExcludedElement(), -1); 6369 if (element.hasNameElement()) 6370 composeString(t, "ExplanationOfBenefit", "name", element.getNameElement(), -1); 6371 if (element.hasDescriptionElement()) 6372 composeString(t, "ExplanationOfBenefit", "description", element.getDescriptionElement(), -1); 6373 if (element.hasNetwork()) 6374 composeCodeableConcept(t, "ExplanationOfBenefit", "network", element.getNetwork(), -1); 6375 if (element.hasUnit()) 6376 composeCodeableConcept(t, "ExplanationOfBenefit", "unit", element.getUnit(), -1); 6377 if (element.hasTerm()) 6378 composeCodeableConcept(t, "ExplanationOfBenefit", "term", element.getTerm(), -1); 6379 for (int i = 0; i < element.getFinancial().size(); i++) 6380 composeExplanationOfBenefitBenefitComponent(t, "ExplanationOfBenefit", "financial", element.getFinancial().get(i), i); 6381 } 6382 6383 protected void composeExplanationOfBenefitBenefitComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitComponent element, int index) { 6384 if (element == null) 6385 return; 6386 Complex t; 6387 if (Utilities.noString(parentType)) 6388 t = parent; 6389 else { 6390 t = parent.predicate("fhir:"+parentType+'.'+name); 6391 } 6392 composeBackboneElement(t, "financial", name, element, index); 6393 if (element.hasType()) 6394 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6395 if (element.hasAllowed()) 6396 composeType(t, "ExplanationOfBenefit", "allowed", element.getAllowed(), -1); 6397 if (element.hasUsed()) 6398 composeType(t, "ExplanationOfBenefit", "used", element.getUsed(), -1); 6399 } 6400 6401 protected void composeFamilyMemberHistory(Complex parent, String parentType, String name, FamilyMemberHistory element, int index) { 6402 if (element == null) 6403 return; 6404 Complex t; 6405 if (Utilities.noString(parentType)) 6406 t = parent; 6407 else { 6408 t = parent.predicate("fhir:"+parentType+'.'+name); 6409 } 6410 composeDomainResource(t, "FamilyMemberHistory", name, element, index); 6411 for (int i = 0; i < element.getIdentifier().size(); i++) 6412 composeIdentifier(t, "FamilyMemberHistory", "identifier", element.getIdentifier().get(i), i); 6413 for (int i = 0; i < element.getDefinition().size(); i++) 6414 composeReference(t, "FamilyMemberHistory", "definition", element.getDefinition().get(i), i); 6415 if (element.hasStatusElement()) 6416 composeEnum(t, "FamilyMemberHistory", "status", element.getStatusElement(), -1); 6417 if (element.hasNotDoneElement()) 6418 composeBoolean(t, "FamilyMemberHistory", "notDone", element.getNotDoneElement(), -1); 6419 if (element.hasNotDoneReason()) 6420 composeCodeableConcept(t, "FamilyMemberHistory", "notDoneReason", element.getNotDoneReason(), -1); 6421 if (element.hasPatient()) 6422 composeReference(t, "FamilyMemberHistory", "patient", element.getPatient(), -1); 6423 if (element.hasDateElement()) 6424 composeDateTime(t, "FamilyMemberHistory", "date", element.getDateElement(), -1); 6425 if (element.hasNameElement()) 6426 composeString(t, "FamilyMemberHistory", "name", element.getNameElement(), -1); 6427 if (element.hasRelationship()) 6428 composeCodeableConcept(t, "FamilyMemberHistory", "relationship", element.getRelationship(), -1); 6429 if (element.hasGenderElement()) 6430 composeEnum(t, "FamilyMemberHistory", "gender", element.getGenderElement(), -1); 6431 if (element.hasBorn()) 6432 composeType(t, "FamilyMemberHistory", "born", element.getBorn(), -1); 6433 if (element.hasAge()) 6434 composeType(t, "FamilyMemberHistory", "age", element.getAge(), -1); 6435 if (element.hasEstimatedAgeElement()) 6436 composeBoolean(t, "FamilyMemberHistory", "estimatedAge", element.getEstimatedAgeElement(), -1); 6437 if (element.hasDeceased()) 6438 composeType(t, "FamilyMemberHistory", "deceased", element.getDeceased(), -1); 6439 for (int i = 0; i < element.getReasonCode().size(); i++) 6440 composeCodeableConcept(t, "FamilyMemberHistory", "reasonCode", element.getReasonCode().get(i), i); 6441 for (int i = 0; i < element.getReasonReference().size(); i++) 6442 composeReference(t, "FamilyMemberHistory", "reasonReference", element.getReasonReference().get(i), i); 6443 for (int i = 0; i < element.getNote().size(); i++) 6444 composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i); 6445 for (int i = 0; i < element.getCondition().size(); i++) 6446 composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(t, "FamilyMemberHistory", "condition", element.getCondition().get(i), i); 6447 } 6448 6449 protected void composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryConditionComponent element, int index) { 6450 if (element == null) 6451 return; 6452 Complex t; 6453 if (Utilities.noString(parentType)) 6454 t = parent; 6455 else { 6456 t = parent.predicate("fhir:"+parentType+'.'+name); 6457 } 6458 composeBackboneElement(t, "condition", name, element, index); 6459 if (element.hasCode()) 6460 composeCodeableConcept(t, "FamilyMemberHistory", "code", element.getCode(), -1); 6461 if (element.hasOutcome()) 6462 composeCodeableConcept(t, "FamilyMemberHistory", "outcome", element.getOutcome(), -1); 6463 if (element.hasOnset()) 6464 composeType(t, "FamilyMemberHistory", "onset", element.getOnset(), -1); 6465 for (int i = 0; i < element.getNote().size(); i++) 6466 composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i); 6467 } 6468 6469 protected void composeFlag(Complex parent, String parentType, String name, Flag 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 composeDomainResource(t, "Flag", name, element, index); 6479 for (int i = 0; i < element.getIdentifier().size(); i++) 6480 composeIdentifier(t, "Flag", "identifier", element.getIdentifier().get(i), i); 6481 if (element.hasStatusElement()) 6482 composeEnum(t, "Flag", "status", element.getStatusElement(), -1); 6483 if (element.hasCategory()) 6484 composeCodeableConcept(t, "Flag", "category", element.getCategory(), -1); 6485 if (element.hasCode()) 6486 composeCodeableConcept(t, "Flag", "code", element.getCode(), -1); 6487 if (element.hasSubject()) 6488 composeReference(t, "Flag", "subject", element.getSubject(), -1); 6489 if (element.hasPeriod()) 6490 composePeriod(t, "Flag", "period", element.getPeriod(), -1); 6491 if (element.hasEncounter()) 6492 composeReference(t, "Flag", "encounter", element.getEncounter(), -1); 6493 if (element.hasAuthor()) 6494 composeReference(t, "Flag", "author", element.getAuthor(), -1); 6495 } 6496 6497 protected void composeGoal(Complex parent, String parentType, String name, Goal element, int index) { 6498 if (element == null) 6499 return; 6500 Complex t; 6501 if (Utilities.noString(parentType)) 6502 t = parent; 6503 else { 6504 t = parent.predicate("fhir:"+parentType+'.'+name); 6505 } 6506 composeDomainResource(t, "Goal", name, element, index); 6507 for (int i = 0; i < element.getIdentifier().size(); i++) 6508 composeIdentifier(t, "Goal", "identifier", element.getIdentifier().get(i), i); 6509 if (element.hasStatusElement()) 6510 composeEnum(t, "Goal", "status", element.getStatusElement(), -1); 6511 for (int i = 0; i < element.getCategory().size(); i++) 6512 composeCodeableConcept(t, "Goal", "category", element.getCategory().get(i), i); 6513 if (element.hasPriority()) 6514 composeCodeableConcept(t, "Goal", "priority", element.getPriority(), -1); 6515 if (element.hasDescription()) 6516 composeCodeableConcept(t, "Goal", "description", element.getDescription(), -1); 6517 if (element.hasSubject()) 6518 composeReference(t, "Goal", "subject", element.getSubject(), -1); 6519 if (element.hasStart()) 6520 composeType(t, "Goal", "start", element.getStart(), -1); 6521 if (element.hasTarget()) 6522 composeGoalGoalTargetComponent(t, "Goal", "target", element.getTarget(), -1); 6523 if (element.hasStatusDateElement()) 6524 composeDate(t, "Goal", "statusDate", element.getStatusDateElement(), -1); 6525 if (element.hasStatusReasonElement()) 6526 composeString(t, "Goal", "statusReason", element.getStatusReasonElement(), -1); 6527 if (element.hasExpressedBy()) 6528 composeReference(t, "Goal", "expressedBy", element.getExpressedBy(), -1); 6529 for (int i = 0; i < element.getAddresses().size(); i++) 6530 composeReference(t, "Goal", "addresses", element.getAddresses().get(i), i); 6531 for (int i = 0; i < element.getNote().size(); i++) 6532 composeAnnotation(t, "Goal", "note", element.getNote().get(i), i); 6533 for (int i = 0; i < element.getOutcomeCode().size(); i++) 6534 composeCodeableConcept(t, "Goal", "outcomeCode", element.getOutcomeCode().get(i), i); 6535 for (int i = 0; i < element.getOutcomeReference().size(); i++) 6536 composeReference(t, "Goal", "outcomeReference", element.getOutcomeReference().get(i), i); 6537 } 6538 6539 protected void composeGoalGoalTargetComponent(Complex parent, String parentType, String name, Goal.GoalTargetComponent element, int index) { 6540 if (element == null) 6541 return; 6542 Complex t; 6543 if (Utilities.noString(parentType)) 6544 t = parent; 6545 else { 6546 t = parent.predicate("fhir:"+parentType+'.'+name); 6547 } 6548 composeBackboneElement(t, "target", name, element, index); 6549 if (element.hasMeasure()) 6550 composeCodeableConcept(t, "Goal", "measure", element.getMeasure(), -1); 6551 if (element.hasDetail()) 6552 composeType(t, "Goal", "detail", element.getDetail(), -1); 6553 if (element.hasDue()) 6554 composeType(t, "Goal", "due", element.getDue(), -1); 6555 } 6556 6557 protected void composeGraphDefinition(Complex parent, String parentType, String name, GraphDefinition element, int index) { 6558 if (element == null) 6559 return; 6560 Complex t; 6561 if (Utilities.noString(parentType)) 6562 t = parent; 6563 else { 6564 t = parent.predicate("fhir:"+parentType+'.'+name); 6565 } 6566 composeDomainResource(t, "GraphDefinition", name, element, index); 6567 if (element.hasUrlElement()) 6568 composeUri(t, "GraphDefinition", "url", element.getUrlElement(), -1); 6569 if (element.hasVersionElement()) 6570 composeString(t, "GraphDefinition", "version", element.getVersionElement(), -1); 6571 if (element.hasNameElement()) 6572 composeString(t, "GraphDefinition", "name", element.getNameElement(), -1); 6573 if (element.hasStatusElement()) 6574 composeEnum(t, "GraphDefinition", "status", element.getStatusElement(), -1); 6575 if (element.hasExperimentalElement()) 6576 composeBoolean(t, "GraphDefinition", "experimental", element.getExperimentalElement(), -1); 6577 if (element.hasDateElement()) 6578 composeDateTime(t, "GraphDefinition", "date", element.getDateElement(), -1); 6579 if (element.hasPublisherElement()) 6580 composeString(t, "GraphDefinition", "publisher", element.getPublisherElement(), -1); 6581 for (int i = 0; i < element.getContact().size(); i++) 6582 composeContactDetail(t, "GraphDefinition", "contact", element.getContact().get(i), i); 6583 if (element.hasDescriptionElement()) 6584 composeMarkdown(t, "GraphDefinition", "description", element.getDescriptionElement(), -1); 6585 for (int i = 0; i < element.getUseContext().size(); i++) 6586 composeUsageContext(t, "GraphDefinition", "useContext", element.getUseContext().get(i), i); 6587 for (int i = 0; i < element.getJurisdiction().size(); i++) 6588 composeCodeableConcept(t, "GraphDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 6589 if (element.hasPurposeElement()) 6590 composeMarkdown(t, "GraphDefinition", "purpose", element.getPurposeElement(), -1); 6591 if (element.hasStartElement()) 6592 composeCode(t, "GraphDefinition", "start", element.getStartElement(), -1); 6593 if (element.hasProfileElement()) 6594 composeUri(t, "GraphDefinition", "profile", element.getProfileElement(), -1); 6595 for (int i = 0; i < element.getLink().size(); i++) 6596 composeGraphDefinitionGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i); 6597 } 6598 6599 protected void composeGraphDefinitionGraphDefinitionLinkComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkComponent element, int index) { 6600 if (element == null) 6601 return; 6602 Complex t; 6603 if (Utilities.noString(parentType)) 6604 t = parent; 6605 else { 6606 t = parent.predicate("fhir:"+parentType+'.'+name); 6607 } 6608 composeBackboneElement(t, "link", name, element, index); 6609 if (element.hasPathElement()) 6610 composeString(t, "GraphDefinition", "path", element.getPathElement(), -1); 6611 if (element.hasSliceNameElement()) 6612 composeString(t, "GraphDefinition", "sliceName", element.getSliceNameElement(), -1); 6613 if (element.hasMinElement()) 6614 composeInteger(t, "GraphDefinition", "min", element.getMinElement(), -1); 6615 if (element.hasMaxElement()) 6616 composeString(t, "GraphDefinition", "max", element.getMaxElement(), -1); 6617 if (element.hasDescriptionElement()) 6618 composeString(t, "GraphDefinition", "description", element.getDescriptionElement(), -1); 6619 for (int i = 0; i < element.getTarget().size(); i++) 6620 composeGraphDefinitionGraphDefinitionLinkTargetComponent(t, "GraphDefinition", "target", element.getTarget().get(i), i); 6621 } 6622 6623 protected void composeGraphDefinitionGraphDefinitionLinkTargetComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetComponent element, int index) { 6624 if (element == null) 6625 return; 6626 Complex t; 6627 if (Utilities.noString(parentType)) 6628 t = parent; 6629 else { 6630 t = parent.predicate("fhir:"+parentType+'.'+name); 6631 } 6632 composeBackboneElement(t, "target", name, element, index); 6633 if (element.hasTypeElement()) 6634 composeCode(t, "GraphDefinition", "type", element.getTypeElement(), -1); 6635 if (element.hasProfileElement()) 6636 composeUri(t, "GraphDefinition", "profile", element.getProfileElement(), -1); 6637 for (int i = 0; i < element.getCompartment().size(); i++) 6638 composeGraphDefinitionGraphDefinitionLinkTargetCompartmentComponent(t, "GraphDefinition", "compartment", element.getCompartment().get(i), i); 6639 for (int i = 0; i < element.getLink().size(); i++) 6640 composeGraphDefinitionGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i); 6641 } 6642 6643 protected void composeGraphDefinitionGraphDefinitionLinkTargetCompartmentComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetCompartmentComponent 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, "compartment", name, element, index); 6653 if (element.hasCodeElement()) 6654 composeEnum(t, "GraphDefinition", "code", element.getCodeElement(), -1); 6655 if (element.hasRuleElement()) 6656 composeEnum(t, "GraphDefinition", "rule", element.getRuleElement(), -1); 6657 if (element.hasExpressionElement()) 6658 composeString(t, "GraphDefinition", "expression", element.getExpressionElement(), -1); 6659 if (element.hasDescriptionElement()) 6660 composeString(t, "GraphDefinition", "description", element.getDescriptionElement(), -1); 6661 } 6662 6663 protected void composeGroup(Complex parent, String parentType, String name, Group 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 composeDomainResource(t, "Group", name, element, index); 6673 for (int i = 0; i < element.getIdentifier().size(); i++) 6674 composeIdentifier(t, "Group", "identifier", element.getIdentifier().get(i), i); 6675 if (element.hasActiveElement()) 6676 composeBoolean(t, "Group", "active", element.getActiveElement(), -1); 6677 if (element.hasTypeElement()) 6678 composeEnum(t, "Group", "type", element.getTypeElement(), -1); 6679 if (element.hasActualElement()) 6680 composeBoolean(t, "Group", "actual", element.getActualElement(), -1); 6681 if (element.hasCode()) 6682 composeCodeableConcept(t, "Group", "code", element.getCode(), -1); 6683 if (element.hasNameElement()) 6684 composeString(t, "Group", "name", element.getNameElement(), -1); 6685 if (element.hasQuantityElement()) 6686 composeUnsignedInt(t, "Group", "quantity", element.getQuantityElement(), -1); 6687 for (int i = 0; i < element.getCharacteristic().size(); i++) 6688 composeGroupGroupCharacteristicComponent(t, "Group", "characteristic", element.getCharacteristic().get(i), i); 6689 for (int i = 0; i < element.getMember().size(); i++) 6690 composeGroupGroupMemberComponent(t, "Group", "member", element.getMember().get(i), i); 6691 } 6692 6693 protected void composeGroupGroupCharacteristicComponent(Complex parent, String parentType, String name, Group.GroupCharacteristicComponent element, int index) { 6694 if (element == null) 6695 return; 6696 Complex t; 6697 if (Utilities.noString(parentType)) 6698 t = parent; 6699 else { 6700 t = parent.predicate("fhir:"+parentType+'.'+name); 6701 } 6702 composeBackboneElement(t, "characteristic", name, element, index); 6703 if (element.hasCode()) 6704 composeCodeableConcept(t, "Group", "code", element.getCode(), -1); 6705 if (element.hasValue()) 6706 composeType(t, "Group", "value", element.getValue(), -1); 6707 if (element.hasExcludeElement()) 6708 composeBoolean(t, "Group", "exclude", element.getExcludeElement(), -1); 6709 if (element.hasPeriod()) 6710 composePeriod(t, "Group", "period", element.getPeriod(), -1); 6711 } 6712 6713 protected void composeGroupGroupMemberComponent(Complex parent, String parentType, String name, Group.GroupMemberComponent 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, "member", name, element, index); 6723 if (element.hasEntity()) 6724 composeReference(t, "Group", "entity", element.getEntity(), -1); 6725 if (element.hasPeriod()) 6726 composePeriod(t, "Group", "period", element.getPeriod(), -1); 6727 if (element.hasInactiveElement()) 6728 composeBoolean(t, "Group", "inactive", element.getInactiveElement(), -1); 6729 } 6730 6731 protected void composeGuidanceResponse(Complex parent, String parentType, String name, GuidanceResponse element, int index) { 6732 if (element == null) 6733 return; 6734 Complex t; 6735 if (Utilities.noString(parentType)) 6736 t = parent; 6737 else { 6738 t = parent.predicate("fhir:"+parentType+'.'+name); 6739 } 6740 composeDomainResource(t, "GuidanceResponse", name, element, index); 6741 if (element.hasRequestIdElement()) 6742 composeId(t, "GuidanceResponse", "requestId", element.getRequestIdElement(), -1); 6743 if (element.hasIdentifier()) 6744 composeIdentifier(t, "GuidanceResponse", "identifier", element.getIdentifier(), -1); 6745 if (element.hasModule()) 6746 composeReference(t, "GuidanceResponse", "module", element.getModule(), -1); 6747 if (element.hasStatusElement()) 6748 composeEnum(t, "GuidanceResponse", "status", element.getStatusElement(), -1); 6749 if (element.hasSubject()) 6750 composeReference(t, "GuidanceResponse", "subject", element.getSubject(), -1); 6751 if (element.hasContext()) 6752 composeReference(t, "GuidanceResponse", "context", element.getContext(), -1); 6753 if (element.hasOccurrenceDateTimeElement()) 6754 composeDateTime(t, "GuidanceResponse", "occurrenceDateTime", element.getOccurrenceDateTimeElement(), -1); 6755 if (element.hasPerformer()) 6756 composeReference(t, "GuidanceResponse", "performer", element.getPerformer(), -1); 6757 if (element.hasReason()) 6758 composeType(t, "GuidanceResponse", "reason", element.getReason(), -1); 6759 for (int i = 0; i < element.getNote().size(); i++) 6760 composeAnnotation(t, "GuidanceResponse", "note", element.getNote().get(i), i); 6761 for (int i = 0; i < element.getEvaluationMessage().size(); i++) 6762 composeReference(t, "GuidanceResponse", "evaluationMessage", element.getEvaluationMessage().get(i), i); 6763 if (element.hasOutputParameters()) 6764 composeReference(t, "GuidanceResponse", "outputParameters", element.getOutputParameters(), -1); 6765 if (element.hasResult()) 6766 composeReference(t, "GuidanceResponse", "result", element.getResult(), -1); 6767 for (int i = 0; i < element.getDataRequirement().size(); i++) 6768 composeDataRequirement(t, "GuidanceResponse", "dataRequirement", element.getDataRequirement().get(i), i); 6769 } 6770 6771 protected void composeHealthcareService(Complex parent, String parentType, String name, HealthcareService element, int index) { 6772 if (element == null) 6773 return; 6774 Complex t; 6775 if (Utilities.noString(parentType)) 6776 t = parent; 6777 else { 6778 t = parent.predicate("fhir:"+parentType+'.'+name); 6779 } 6780 composeDomainResource(t, "HealthcareService", name, element, index); 6781 for (int i = 0; i < element.getIdentifier().size(); i++) 6782 composeIdentifier(t, "HealthcareService", "identifier", element.getIdentifier().get(i), i); 6783 if (element.hasActiveElement()) 6784 composeBoolean(t, "HealthcareService", "active", element.getActiveElement(), -1); 6785 if (element.hasProvidedBy()) 6786 composeReference(t, "HealthcareService", "providedBy", element.getProvidedBy(), -1); 6787 if (element.hasCategory()) 6788 composeCodeableConcept(t, "HealthcareService", "category", element.getCategory(), -1); 6789 for (int i = 0; i < element.getType().size(); i++) 6790 composeCodeableConcept(t, "HealthcareService", "type", element.getType().get(i), i); 6791 for (int i = 0; i < element.getSpecialty().size(); i++) 6792 composeCodeableConcept(t, "HealthcareService", "specialty", element.getSpecialty().get(i), i); 6793 for (int i = 0; i < element.getLocation().size(); i++) 6794 composeReference(t, "HealthcareService", "location", element.getLocation().get(i), i); 6795 if (element.hasNameElement()) 6796 composeString(t, "HealthcareService", "name", element.getNameElement(), -1); 6797 if (element.hasCommentElement()) 6798 composeString(t, "HealthcareService", "comment", element.getCommentElement(), -1); 6799 if (element.hasExtraDetailsElement()) 6800 composeString(t, "HealthcareService", "extraDetails", element.getExtraDetailsElement(), -1); 6801 if (element.hasPhoto()) 6802 composeAttachment(t, "HealthcareService", "photo", element.getPhoto(), -1); 6803 for (int i = 0; i < element.getTelecom().size(); i++) 6804 composeContactPoint(t, "HealthcareService", "telecom", element.getTelecom().get(i), i); 6805 for (int i = 0; i < element.getCoverageArea().size(); i++) 6806 composeReference(t, "HealthcareService", "coverageArea", element.getCoverageArea().get(i), i); 6807 for (int i = 0; i < element.getServiceProvisionCode().size(); i++) 6808 composeCodeableConcept(t, "HealthcareService", "serviceProvisionCode", element.getServiceProvisionCode().get(i), i); 6809 if (element.hasEligibility()) 6810 composeCodeableConcept(t, "HealthcareService", "eligibility", element.getEligibility(), -1); 6811 if (element.hasEligibilityNoteElement()) 6812 composeString(t, "HealthcareService", "eligibilityNote", element.getEligibilityNoteElement(), -1); 6813 for (int i = 0; i < element.getProgramName().size(); i++) 6814 composeString(t, "HealthcareService", "programName", element.getProgramName().get(i), i); 6815 for (int i = 0; i < element.getCharacteristic().size(); i++) 6816 composeCodeableConcept(t, "HealthcareService", "characteristic", element.getCharacteristic().get(i), i); 6817 for (int i = 0; i < element.getReferralMethod().size(); i++) 6818 composeCodeableConcept(t, "HealthcareService", "referralMethod", element.getReferralMethod().get(i), i); 6819 if (element.hasAppointmentRequiredElement()) 6820 composeBoolean(t, "HealthcareService", "appointmentRequired", element.getAppointmentRequiredElement(), -1); 6821 for (int i = 0; i < element.getAvailableTime().size(); i++) 6822 composeHealthcareServiceHealthcareServiceAvailableTimeComponent(t, "HealthcareService", "availableTime", element.getAvailableTime().get(i), i); 6823 for (int i = 0; i < element.getNotAvailable().size(); i++) 6824 composeHealthcareServiceHealthcareServiceNotAvailableComponent(t, "HealthcareService", "notAvailable", element.getNotAvailable().get(i), i); 6825 if (element.hasAvailabilityExceptionsElement()) 6826 composeString(t, "HealthcareService", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1); 6827 for (int i = 0; i < element.getEndpoint().size(); i++) 6828 composeReference(t, "HealthcareService", "endpoint", element.getEndpoint().get(i), i); 6829 } 6830 6831 protected void composeHealthcareServiceHealthcareServiceAvailableTimeComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceAvailableTimeComponent element, int index) { 6832 if (element == null) 6833 return; 6834 Complex t; 6835 if (Utilities.noString(parentType)) 6836 t = parent; 6837 else { 6838 t = parent.predicate("fhir:"+parentType+'.'+name); 6839 } 6840 composeBackboneElement(t, "availableTime", name, element, index); 6841 for (int i = 0; i < element.getDaysOfWeek().size(); i++) 6842 composeEnum(t, "HealthcareService", "daysOfWeek", element.getDaysOfWeek().get(i), i); 6843 if (element.hasAllDayElement()) 6844 composeBoolean(t, "HealthcareService", "allDay", element.getAllDayElement(), -1); 6845 if (element.hasAvailableStartTimeElement()) 6846 composeTime(t, "HealthcareService", "availableStartTime", element.getAvailableStartTimeElement(), -1); 6847 if (element.hasAvailableEndTimeElement()) 6848 composeTime(t, "HealthcareService", "availableEndTime", element.getAvailableEndTimeElement(), -1); 6849 } 6850 6851 protected void composeHealthcareServiceHealthcareServiceNotAvailableComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceNotAvailableComponent 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, "notAvailable", name, element, index); 6861 if (element.hasDescriptionElement()) 6862 composeString(t, "HealthcareService", "description", element.getDescriptionElement(), -1); 6863 if (element.hasDuring()) 6864 composePeriod(t, "HealthcareService", "during", element.getDuring(), -1); 6865 } 6866 6867 protected void composeImagingManifest(Complex parent, String parentType, String name, ImagingManifest element, int index) { 6868 if (element == null) 6869 return; 6870 Complex t; 6871 if (Utilities.noString(parentType)) 6872 t = parent; 6873 else { 6874 t = parent.predicate("fhir:"+parentType+'.'+name); 6875 } 6876 composeDomainResource(t, "ImagingManifest", name, element, index); 6877 if (element.hasIdentifier()) 6878 composeIdentifier(t, "ImagingManifest", "identifier", element.getIdentifier(), -1); 6879 if (element.hasPatient()) 6880 composeReference(t, "ImagingManifest", "patient", element.getPatient(), -1); 6881 if (element.hasAuthoringTimeElement()) 6882 composeDateTime(t, "ImagingManifest", "authoringTime", element.getAuthoringTimeElement(), -1); 6883 if (element.hasAuthor()) 6884 composeReference(t, "ImagingManifest", "author", element.getAuthor(), -1); 6885 if (element.hasDescriptionElement()) 6886 composeString(t, "ImagingManifest", "description", element.getDescriptionElement(), -1); 6887 for (int i = 0; i < element.getStudy().size(); i++) 6888 composeImagingManifestStudyComponent(t, "ImagingManifest", "study", element.getStudy().get(i), i); 6889 } 6890 6891 protected void composeImagingManifestStudyComponent(Complex parent, String parentType, String name, ImagingManifest.StudyComponent element, int index) { 6892 if (element == null) 6893 return; 6894 Complex t; 6895 if (Utilities.noString(parentType)) 6896 t = parent; 6897 else { 6898 t = parent.predicate("fhir:"+parentType+'.'+name); 6899 } 6900 composeBackboneElement(t, "study", name, element, index); 6901 if (element.hasUidElement()) 6902 composeOid(t, "ImagingManifest", "uid", element.getUidElement(), -1); 6903 if (element.hasImagingStudy()) 6904 composeReference(t, "ImagingManifest", "imagingStudy", element.getImagingStudy(), -1); 6905 for (int i = 0; i < element.getEndpoint().size(); i++) 6906 composeReference(t, "ImagingManifest", "endpoint", element.getEndpoint().get(i), i); 6907 for (int i = 0; i < element.getSeries().size(); i++) 6908 composeImagingManifestSeriesComponent(t, "ImagingManifest", "series", element.getSeries().get(i), i); 6909 } 6910 6911 protected void composeImagingManifestSeriesComponent(Complex parent, String parentType, String name, ImagingManifest.SeriesComponent 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, "series", name, element, index); 6921 if (element.hasUidElement()) 6922 composeOid(t, "ImagingManifest", "uid", element.getUidElement(), -1); 6923 for (int i = 0; i < element.getEndpoint().size(); i++) 6924 composeReference(t, "ImagingManifest", "endpoint", element.getEndpoint().get(i), i); 6925 for (int i = 0; i < element.getInstance().size(); i++) 6926 composeImagingManifestInstanceComponent(t, "ImagingManifest", "instance", element.getInstance().get(i), i); 6927 } 6928 6929 protected void composeImagingManifestInstanceComponent(Complex parent, String parentType, String name, ImagingManifest.InstanceComponent element, int index) { 6930 if (element == null) 6931 return; 6932 Complex t; 6933 if (Utilities.noString(parentType)) 6934 t = parent; 6935 else { 6936 t = parent.predicate("fhir:"+parentType+'.'+name); 6937 } 6938 composeBackboneElement(t, "instance", name, element, index); 6939 if (element.hasSopClassElement()) 6940 composeOid(t, "ImagingManifest", "sopClass", element.getSopClassElement(), -1); 6941 if (element.hasUidElement()) 6942 composeOid(t, "ImagingManifest", "uid", element.getUidElement(), -1); 6943 } 6944 6945 protected void composeImagingStudy(Complex parent, String parentType, String name, ImagingStudy element, int index) { 6946 if (element == null) 6947 return; 6948 Complex t; 6949 if (Utilities.noString(parentType)) 6950 t = parent; 6951 else { 6952 t = parent.predicate("fhir:"+parentType+'.'+name); 6953 } 6954 composeDomainResource(t, "ImagingStudy", name, element, index); 6955 if (element.hasUidElement()) 6956 composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1); 6957 if (element.hasAccession()) 6958 composeIdentifier(t, "ImagingStudy", "accession", element.getAccession(), -1); 6959 for (int i = 0; i < element.getIdentifier().size(); i++) 6960 composeIdentifier(t, "ImagingStudy", "identifier", element.getIdentifier().get(i), i); 6961 if (element.hasAvailabilityElement()) 6962 composeEnum(t, "ImagingStudy", "availability", element.getAvailabilityElement(), -1); 6963 for (int i = 0; i < element.getModalityList().size(); i++) 6964 composeCoding(t, "ImagingStudy", "modalityList", element.getModalityList().get(i), i); 6965 if (element.hasPatient()) 6966 composeReference(t, "ImagingStudy", "patient", element.getPatient(), -1); 6967 if (element.hasContext()) 6968 composeReference(t, "ImagingStudy", "context", element.getContext(), -1); 6969 if (element.hasStartedElement()) 6970 composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1); 6971 for (int i = 0; i < element.getBasedOn().size(); i++) 6972 composeReference(t, "ImagingStudy", "basedOn", element.getBasedOn().get(i), i); 6973 if (element.hasReferrer()) 6974 composeReference(t, "ImagingStudy", "referrer", element.getReferrer(), -1); 6975 for (int i = 0; i < element.getInterpreter().size(); i++) 6976 composeReference(t, "ImagingStudy", "interpreter", element.getInterpreter().get(i), i); 6977 for (int i = 0; i < element.getEndpoint().size(); i++) 6978 composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i); 6979 if (element.hasNumberOfSeriesElement()) 6980 composeUnsignedInt(t, "ImagingStudy", "numberOfSeries", element.getNumberOfSeriesElement(), -1); 6981 if (element.hasNumberOfInstancesElement()) 6982 composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1); 6983 for (int i = 0; i < element.getProcedureReference().size(); i++) 6984 composeReference(t, "ImagingStudy", "procedureReference", element.getProcedureReference().get(i), i); 6985 for (int i = 0; i < element.getProcedureCode().size(); i++) 6986 composeCodeableConcept(t, "ImagingStudy", "procedureCode", element.getProcedureCode().get(i), i); 6987 if (element.hasReason()) 6988 composeCodeableConcept(t, "ImagingStudy", "reason", element.getReason(), -1); 6989 if (element.hasDescriptionElement()) 6990 composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1); 6991 for (int i = 0; i < element.getSeries().size(); i++) 6992 composeImagingStudyImagingStudySeriesComponent(t, "ImagingStudy", "series", element.getSeries().get(i), i); 6993 } 6994 6995 protected void composeImagingStudyImagingStudySeriesComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesComponent element, int index) { 6996 if (element == null) 6997 return; 6998 Complex t; 6999 if (Utilities.noString(parentType)) 7000 t = parent; 7001 else { 7002 t = parent.predicate("fhir:"+parentType+'.'+name); 7003 } 7004 composeBackboneElement(t, "series", name, element, index); 7005 if (element.hasUidElement()) 7006 composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1); 7007 if (element.hasNumberElement()) 7008 composeUnsignedInt(t, "ImagingStudy", "number", element.getNumberElement(), -1); 7009 if (element.hasModality()) 7010 composeCoding(t, "ImagingStudy", "modality", element.getModality(), -1); 7011 if (element.hasDescriptionElement()) 7012 composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1); 7013 if (element.hasNumberOfInstancesElement()) 7014 composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1); 7015 if (element.hasAvailabilityElement()) 7016 composeEnum(t, "ImagingStudy", "availability", element.getAvailabilityElement(), -1); 7017 for (int i = 0; i < element.getEndpoint().size(); i++) 7018 composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i); 7019 if (element.hasBodySite()) 7020 composeCoding(t, "ImagingStudy", "bodySite", element.getBodySite(), -1); 7021 if (element.hasLaterality()) 7022 composeCoding(t, "ImagingStudy", "laterality", element.getLaterality(), -1); 7023 if (element.hasStartedElement()) 7024 composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1); 7025 for (int i = 0; i < element.getPerformer().size(); i++) 7026 composeReference(t, "ImagingStudy", "performer", element.getPerformer().get(i), i); 7027 for (int i = 0; i < element.getInstance().size(); i++) 7028 composeImagingStudyImagingStudySeriesInstanceComponent(t, "ImagingStudy", "instance", element.getInstance().get(i), i); 7029 } 7030 7031 protected void composeImagingStudyImagingStudySeriesInstanceComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesInstanceComponent element, int index) { 7032 if (element == null) 7033 return; 7034 Complex t; 7035 if (Utilities.noString(parentType)) 7036 t = parent; 7037 else { 7038 t = parent.predicate("fhir:"+parentType+'.'+name); 7039 } 7040 composeBackboneElement(t, "instance", name, element, index); 7041 if (element.hasUidElement()) 7042 composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1); 7043 if (element.hasNumberElement()) 7044 composeUnsignedInt(t, "ImagingStudy", "number", element.getNumberElement(), -1); 7045 if (element.hasSopClassElement()) 7046 composeOid(t, "ImagingStudy", "sopClass", element.getSopClassElement(), -1); 7047 if (element.hasTitleElement()) 7048 composeString(t, "ImagingStudy", "title", element.getTitleElement(), -1); 7049 } 7050 7051 protected void composeImmunization(Complex parent, String parentType, String name, Immunization element, int index) { 7052 if (element == null) 7053 return; 7054 Complex t; 7055 if (Utilities.noString(parentType)) 7056 t = parent; 7057 else { 7058 t = parent.predicate("fhir:"+parentType+'.'+name); 7059 } 7060 composeDomainResource(t, "Immunization", name, element, index); 7061 for (int i = 0; i < element.getIdentifier().size(); i++) 7062 composeIdentifier(t, "Immunization", "identifier", element.getIdentifier().get(i), i); 7063 if (element.hasStatusElement()) 7064 composeEnum(t, "Immunization", "status", element.getStatusElement(), -1); 7065 if (element.hasNotGivenElement()) 7066 composeBoolean(t, "Immunization", "notGiven", element.getNotGivenElement(), -1); 7067 if (element.hasVaccineCode()) 7068 composeCodeableConcept(t, "Immunization", "vaccineCode", element.getVaccineCode(), -1); 7069 if (element.hasPatient()) 7070 composeReference(t, "Immunization", "patient", element.getPatient(), -1); 7071 if (element.hasEncounter()) 7072 composeReference(t, "Immunization", "encounter", element.getEncounter(), -1); 7073 if (element.hasDateElement()) 7074 composeDateTime(t, "Immunization", "date", element.getDateElement(), -1); 7075 if (element.hasPrimarySourceElement()) 7076 composeBoolean(t, "Immunization", "primarySource", element.getPrimarySourceElement(), -1); 7077 if (element.hasReportOrigin()) 7078 composeCodeableConcept(t, "Immunization", "reportOrigin", element.getReportOrigin(), -1); 7079 if (element.hasLocation()) 7080 composeReference(t, "Immunization", "location", element.getLocation(), -1); 7081 if (element.hasManufacturer()) 7082 composeReference(t, "Immunization", "manufacturer", element.getManufacturer(), -1); 7083 if (element.hasLotNumberElement()) 7084 composeString(t, "Immunization", "lotNumber", element.getLotNumberElement(), -1); 7085 if (element.hasExpirationDateElement()) 7086 composeDate(t, "Immunization", "expirationDate", element.getExpirationDateElement(), -1); 7087 if (element.hasSite()) 7088 composeCodeableConcept(t, "Immunization", "site", element.getSite(), -1); 7089 if (element.hasRoute()) 7090 composeCodeableConcept(t, "Immunization", "route", element.getRoute(), -1); 7091 if (element.hasDoseQuantity()) 7092 composeQuantity(t, "Immunization", "doseQuantity", element.getDoseQuantity(), -1); 7093 for (int i = 0; i < element.getPractitioner().size(); i++) 7094 composeImmunizationImmunizationPractitionerComponent(t, "Immunization", "practitioner", element.getPractitioner().get(i), i); 7095 for (int i = 0; i < element.getNote().size(); i++) 7096 composeAnnotation(t, "Immunization", "note", element.getNote().get(i), i); 7097 if (element.hasExplanation()) 7098 composeImmunizationImmunizationExplanationComponent(t, "Immunization", "explanation", element.getExplanation(), -1); 7099 for (int i = 0; i < element.getReaction().size(); i++) 7100 composeImmunizationImmunizationReactionComponent(t, "Immunization", "reaction", element.getReaction().get(i), i); 7101 for (int i = 0; i < element.getVaccinationProtocol().size(); i++) 7102 composeImmunizationImmunizationVaccinationProtocolComponent(t, "Immunization", "vaccinationProtocol", element.getVaccinationProtocol().get(i), i); 7103 } 7104 7105 protected void composeImmunizationImmunizationPractitionerComponent(Complex parent, String parentType, String name, Immunization.ImmunizationPractitionerComponent element, int index) { 7106 if (element == null) 7107 return; 7108 Complex t; 7109 if (Utilities.noString(parentType)) 7110 t = parent; 7111 else { 7112 t = parent.predicate("fhir:"+parentType+'.'+name); 7113 } 7114 composeBackboneElement(t, "practitioner", name, element, index); 7115 if (element.hasRole()) 7116 composeCodeableConcept(t, "Immunization", "role", element.getRole(), -1); 7117 if (element.hasActor()) 7118 composeReference(t, "Immunization", "actor", element.getActor(), -1); 7119 } 7120 7121 protected void composeImmunizationImmunizationExplanationComponent(Complex parent, String parentType, String name, Immunization.ImmunizationExplanationComponent element, int index) { 7122 if (element == null) 7123 return; 7124 Complex t; 7125 if (Utilities.noString(parentType)) 7126 t = parent; 7127 else { 7128 t = parent.predicate("fhir:"+parentType+'.'+name); 7129 } 7130 composeBackboneElement(t, "explanation", name, element, index); 7131 for (int i = 0; i < element.getReason().size(); i++) 7132 composeCodeableConcept(t, "Immunization", "reason", element.getReason().get(i), i); 7133 for (int i = 0; i < element.getReasonNotGiven().size(); i++) 7134 composeCodeableConcept(t, "Immunization", "reasonNotGiven", element.getReasonNotGiven().get(i), i); 7135 } 7136 7137 protected void composeImmunizationImmunizationReactionComponent(Complex parent, String parentType, String name, Immunization.ImmunizationReactionComponent element, int index) { 7138 if (element == null) 7139 return; 7140 Complex t; 7141 if (Utilities.noString(parentType)) 7142 t = parent; 7143 else { 7144 t = parent.predicate("fhir:"+parentType+'.'+name); 7145 } 7146 composeBackboneElement(t, "reaction", name, element, index); 7147 if (element.hasDateElement()) 7148 composeDateTime(t, "Immunization", "date", element.getDateElement(), -1); 7149 if (element.hasDetail()) 7150 composeReference(t, "Immunization", "detail", element.getDetail(), -1); 7151 if (element.hasReportedElement()) 7152 composeBoolean(t, "Immunization", "reported", element.getReportedElement(), -1); 7153 } 7154 7155 protected void composeImmunizationImmunizationVaccinationProtocolComponent(Complex parent, String parentType, String name, Immunization.ImmunizationVaccinationProtocolComponent element, int index) { 7156 if (element == null) 7157 return; 7158 Complex t; 7159 if (Utilities.noString(parentType)) 7160 t = parent; 7161 else { 7162 t = parent.predicate("fhir:"+parentType+'.'+name); 7163 } 7164 composeBackboneElement(t, "vaccinationProtocol", name, element, index); 7165 if (element.hasDoseSequenceElement()) 7166 composePositiveInt(t, "Immunization", "doseSequence", element.getDoseSequenceElement(), -1); 7167 if (element.hasDescriptionElement()) 7168 composeString(t, "Immunization", "description", element.getDescriptionElement(), -1); 7169 if (element.hasAuthority()) 7170 composeReference(t, "Immunization", "authority", element.getAuthority(), -1); 7171 if (element.hasSeriesElement()) 7172 composeString(t, "Immunization", "series", element.getSeriesElement(), -1); 7173 if (element.hasSeriesDosesElement()) 7174 composePositiveInt(t, "Immunization", "seriesDoses", element.getSeriesDosesElement(), -1); 7175 for (int i = 0; i < element.getTargetDisease().size(); i++) 7176 composeCodeableConcept(t, "Immunization", "targetDisease", element.getTargetDisease().get(i), i); 7177 if (element.hasDoseStatus()) 7178 composeCodeableConcept(t, "Immunization", "doseStatus", element.getDoseStatus(), -1); 7179 if (element.hasDoseStatusReason()) 7180 composeCodeableConcept(t, "Immunization", "doseStatusReason", element.getDoseStatusReason(), -1); 7181 } 7182 7183 protected void composeImmunizationRecommendation(Complex parent, String parentType, String name, ImmunizationRecommendation element, int index) { 7184 if (element == null) 7185 return; 7186 Complex t; 7187 if (Utilities.noString(parentType)) 7188 t = parent; 7189 else { 7190 t = parent.predicate("fhir:"+parentType+'.'+name); 7191 } 7192 composeDomainResource(t, "ImmunizationRecommendation", name, element, index); 7193 for (int i = 0; i < element.getIdentifier().size(); i++) 7194 composeIdentifier(t, "ImmunizationRecommendation", "identifier", element.getIdentifier().get(i), i); 7195 if (element.hasPatient()) 7196 composeReference(t, "ImmunizationRecommendation", "patient", element.getPatient(), -1); 7197 for (int i = 0; i < element.getRecommendation().size(); i++) 7198 composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(t, "ImmunizationRecommendation", "recommendation", element.getRecommendation().get(i), i); 7199 } 7200 7201 protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent element, int index) { 7202 if (element == null) 7203 return; 7204 Complex t; 7205 if (Utilities.noString(parentType)) 7206 t = parent; 7207 else { 7208 t = parent.predicate("fhir:"+parentType+'.'+name); 7209 } 7210 composeBackboneElement(t, "recommendation", name, element, index); 7211 if (element.hasDateElement()) 7212 composeDateTime(t, "ImmunizationRecommendation", "date", element.getDateElement(), -1); 7213 if (element.hasVaccineCode()) 7214 composeCodeableConcept(t, "ImmunizationRecommendation", "vaccineCode", element.getVaccineCode(), -1); 7215 if (element.hasTargetDisease()) 7216 composeCodeableConcept(t, "ImmunizationRecommendation", "targetDisease", element.getTargetDisease(), -1); 7217 if (element.hasDoseNumberElement()) 7218 composePositiveInt(t, "ImmunizationRecommendation", "doseNumber", element.getDoseNumberElement(), -1); 7219 if (element.hasForecastStatus()) 7220 composeCodeableConcept(t, "ImmunizationRecommendation", "forecastStatus", element.getForecastStatus(), -1); 7221 for (int i = 0; i < element.getDateCriterion().size(); i++) 7222 composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(t, "ImmunizationRecommendation", "dateCriterion", element.getDateCriterion().get(i), i); 7223 if (element.hasProtocol()) 7224 composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(t, "ImmunizationRecommendation", "protocol", element.getProtocol(), -1); 7225 for (int i = 0; i < element.getSupportingImmunization().size(); i++) 7226 composeReference(t, "ImmunizationRecommendation", "supportingImmunization", element.getSupportingImmunization().get(i), i); 7227 for (int i = 0; i < element.getSupportingPatientInformation().size(); i++) 7228 composeReference(t, "ImmunizationRecommendation", "supportingPatientInformation", element.getSupportingPatientInformation().get(i), i); 7229 } 7230 7231 protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent element, int index) { 7232 if (element == null) 7233 return; 7234 Complex t; 7235 if (Utilities.noString(parentType)) 7236 t = parent; 7237 else { 7238 t = parent.predicate("fhir:"+parentType+'.'+name); 7239 } 7240 composeBackboneElement(t, "dateCriterion", name, element, index); 7241 if (element.hasCode()) 7242 composeCodeableConcept(t, "ImmunizationRecommendation", "code", element.getCode(), -1); 7243 if (element.hasValueElement()) 7244 composeDateTime(t, "ImmunizationRecommendation", "value", element.getValueElement(), -1); 7245 } 7246 7247 protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent element, int index) { 7248 if (element == null) 7249 return; 7250 Complex t; 7251 if (Utilities.noString(parentType)) 7252 t = parent; 7253 else { 7254 t = parent.predicate("fhir:"+parentType+'.'+name); 7255 } 7256 composeBackboneElement(t, "protocol", name, element, index); 7257 if (element.hasDoseSequenceElement()) 7258 composePositiveInt(t, "ImmunizationRecommendation", "doseSequence", element.getDoseSequenceElement(), -1); 7259 if (element.hasDescriptionElement()) 7260 composeString(t, "ImmunizationRecommendation", "description", element.getDescriptionElement(), -1); 7261 if (element.hasAuthority()) 7262 composeReference(t, "ImmunizationRecommendation", "authority", element.getAuthority(), -1); 7263 if (element.hasSeriesElement()) 7264 composeString(t, "ImmunizationRecommendation", "series", element.getSeriesElement(), -1); 7265 } 7266 7267 protected void composeImplementationGuide(Complex parent, String parentType, String name, ImplementationGuide 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 composeDomainResource(t, "ImplementationGuide", name, element, index); 7277 if (element.hasUrlElement()) 7278 composeUri(t, "ImplementationGuide", "url", element.getUrlElement(), -1); 7279 if (element.hasVersionElement()) 7280 composeString(t, "ImplementationGuide", "version", element.getVersionElement(), -1); 7281 if (element.hasNameElement()) 7282 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 7283 if (element.hasStatusElement()) 7284 composeEnum(t, "ImplementationGuide", "status", element.getStatusElement(), -1); 7285 if (element.hasExperimentalElement()) 7286 composeBoolean(t, "ImplementationGuide", "experimental", element.getExperimentalElement(), -1); 7287 if (element.hasDateElement()) 7288 composeDateTime(t, "ImplementationGuide", "date", element.getDateElement(), -1); 7289 if (element.hasPublisherElement()) 7290 composeString(t, "ImplementationGuide", "publisher", element.getPublisherElement(), -1); 7291 for (int i = 0; i < element.getContact().size(); i++) 7292 composeContactDetail(t, "ImplementationGuide", "contact", element.getContact().get(i), i); 7293 if (element.hasDescriptionElement()) 7294 composeMarkdown(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 7295 for (int i = 0; i < element.getUseContext().size(); i++) 7296 composeUsageContext(t, "ImplementationGuide", "useContext", element.getUseContext().get(i), i); 7297 for (int i = 0; i < element.getJurisdiction().size(); i++) 7298 composeCodeableConcept(t, "ImplementationGuide", "jurisdiction", element.getJurisdiction().get(i), i); 7299 if (element.hasCopyrightElement()) 7300 composeMarkdown(t, "ImplementationGuide", "copyright", element.getCopyrightElement(), -1); 7301 if (element.hasFhirVersionElement()) 7302 composeId(t, "ImplementationGuide", "fhirVersion", element.getFhirVersionElement(), -1); 7303 for (int i = 0; i < element.getDependency().size(); i++) 7304 composeImplementationGuideImplementationGuideDependencyComponent(t, "ImplementationGuide", "dependency", element.getDependency().get(i), i); 7305 for (int i = 0; i < element.getPackage().size(); i++) 7306 composeImplementationGuideImplementationGuidePackageComponent(t, "ImplementationGuide", "package", element.getPackage().get(i), i); 7307 for (int i = 0; i < element.getGlobal().size(); i++) 7308 composeImplementationGuideImplementationGuideGlobalComponent(t, "ImplementationGuide", "global", element.getGlobal().get(i), i); 7309 for (int i = 0; i < element.getBinary().size(); i++) 7310 composeUri(t, "ImplementationGuide", "binary", element.getBinary().get(i), i); 7311 if (element.hasPage()) 7312 composeImplementationGuideImplementationGuidePageComponent(t, "ImplementationGuide", "page", element.getPage(), -1); 7313 } 7314 7315 protected void composeImplementationGuideImplementationGuideDependencyComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDependencyComponent element, int index) { 7316 if (element == null) 7317 return; 7318 Complex t; 7319 if (Utilities.noString(parentType)) 7320 t = parent; 7321 else { 7322 t = parent.predicate("fhir:"+parentType+'.'+name); 7323 } 7324 composeBackboneElement(t, "dependency", name, element, index); 7325 if (element.hasTypeElement()) 7326 composeEnum(t, "ImplementationGuide", "type", element.getTypeElement(), -1); 7327 if (element.hasUriElement()) 7328 composeUri(t, "ImplementationGuide", "uri", element.getUriElement(), -1); 7329 } 7330 7331 protected void composeImplementationGuideImplementationGuidePackageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePackageComponent element, int index) { 7332 if (element == null) 7333 return; 7334 Complex t; 7335 if (Utilities.noString(parentType)) 7336 t = parent; 7337 else { 7338 t = parent.predicate("fhir:"+parentType+'.'+name); 7339 } 7340 composeBackboneElement(t, "package", name, element, index); 7341 if (element.hasNameElement()) 7342 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 7343 if (element.hasDescriptionElement()) 7344 composeString(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 7345 for (int i = 0; i < element.getResource().size(); i++) 7346 composeImplementationGuideImplementationGuidePackageResourceComponent(t, "ImplementationGuide", "resource", element.getResource().get(i), i); 7347 } 7348 7349 protected void composeImplementationGuideImplementationGuidePackageResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePackageResourceComponent element, int index) { 7350 if (element == null) 7351 return; 7352 Complex t; 7353 if (Utilities.noString(parentType)) 7354 t = parent; 7355 else { 7356 t = parent.predicate("fhir:"+parentType+'.'+name); 7357 } 7358 composeBackboneElement(t, "resource", name, element, index); 7359 if (element.hasExampleElement()) 7360 composeBoolean(t, "ImplementationGuide", "example", element.getExampleElement(), -1); 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 if (element.hasAcronymElement()) 7366 composeString(t, "ImplementationGuide", "acronym", element.getAcronymElement(), -1); 7367 if (element.hasSource()) 7368 composeType(t, "ImplementationGuide", "source", element.getSource(), -1); 7369 if (element.hasExampleFor()) 7370 composeReference(t, "ImplementationGuide", "exampleFor", element.getExampleFor(), -1); 7371 } 7372 7373 protected void composeImplementationGuideImplementationGuideGlobalComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideGlobalComponent element, int index) { 7374 if (element == null) 7375 return; 7376 Complex t; 7377 if (Utilities.noString(parentType)) 7378 t = parent; 7379 else { 7380 t = parent.predicate("fhir:"+parentType+'.'+name); 7381 } 7382 composeBackboneElement(t, "global", name, element, index); 7383 if (element.hasTypeElement()) 7384 composeCode(t, "ImplementationGuide", "type", element.getTypeElement(), -1); 7385 if (element.hasProfile()) 7386 composeReference(t, "ImplementationGuide", "profile", element.getProfile(), -1); 7387 } 7388 7389 protected void composeImplementationGuideImplementationGuidePageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePageComponent element, int index) { 7390 if (element == null) 7391 return; 7392 Complex t; 7393 if (Utilities.noString(parentType)) 7394 t = parent; 7395 else { 7396 t = parent.predicate("fhir:"+parentType+'.'+name); 7397 } 7398 composeBackboneElement(t, "page", name, element, index); 7399 if (element.hasSourceElement()) 7400 composeUri(t, "ImplementationGuide", "source", element.getSourceElement(), -1); 7401 if (element.hasTitleElement()) 7402 composeString(t, "ImplementationGuide", "title", element.getTitleElement(), -1); 7403 if (element.hasKindElement()) 7404 composeEnum(t, "ImplementationGuide", "kind", element.getKindElement(), -1); 7405 for (int i = 0; i < element.getType().size(); i++) 7406 composeCode(t, "ImplementationGuide", "type", element.getType().get(i), i); 7407 for (int i = 0; i < element.getPackage().size(); i++) 7408 composeString(t, "ImplementationGuide", "package", element.getPackage().get(i), i); 7409 if (element.hasFormatElement()) 7410 composeCode(t, "ImplementationGuide", "format", element.getFormatElement(), -1); 7411 for (int i = 0; i < element.getPage().size(); i++) 7412 composeImplementationGuideImplementationGuidePageComponent(t, "ImplementationGuide", "page", element.getPage().get(i), i); 7413 } 7414 7415 protected void composeLibrary(Complex parent, String parentType, String name, Library element, int index) { 7416 if (element == null) 7417 return; 7418 Complex t; 7419 if (Utilities.noString(parentType)) 7420 t = parent; 7421 else { 7422 t = parent.predicate("fhir:"+parentType+'.'+name); 7423 } 7424 composeDomainResource(t, "Library", name, element, index); 7425 if (element.hasUrlElement()) 7426 composeUri(t, "Library", "url", element.getUrlElement(), -1); 7427 for (int i = 0; i < element.getIdentifier().size(); i++) 7428 composeIdentifier(t, "Library", "identifier", element.getIdentifier().get(i), i); 7429 if (element.hasVersionElement()) 7430 composeString(t, "Library", "version", element.getVersionElement(), -1); 7431 if (element.hasNameElement()) 7432 composeString(t, "Library", "name", element.getNameElement(), -1); 7433 if (element.hasTitleElement()) 7434 composeString(t, "Library", "title", element.getTitleElement(), -1); 7435 if (element.hasStatusElement()) 7436 composeEnum(t, "Library", "status", element.getStatusElement(), -1); 7437 if (element.hasExperimentalElement()) 7438 composeBoolean(t, "Library", "experimental", element.getExperimentalElement(), -1); 7439 if (element.hasType()) 7440 composeCodeableConcept(t, "Library", "type", element.getType(), -1); 7441 if (element.hasDateElement()) 7442 composeDateTime(t, "Library", "date", element.getDateElement(), -1); 7443 if (element.hasPublisherElement()) 7444 composeString(t, "Library", "publisher", element.getPublisherElement(), -1); 7445 if (element.hasDescriptionElement()) 7446 composeMarkdown(t, "Library", "description", element.getDescriptionElement(), -1); 7447 if (element.hasPurposeElement()) 7448 composeMarkdown(t, "Library", "purpose", element.getPurposeElement(), -1); 7449 if (element.hasUsageElement()) 7450 composeString(t, "Library", "usage", element.getUsageElement(), -1); 7451 if (element.hasApprovalDateElement()) 7452 composeDate(t, "Library", "approvalDate", element.getApprovalDateElement(), -1); 7453 if (element.hasLastReviewDateElement()) 7454 composeDate(t, "Library", "lastReviewDate", element.getLastReviewDateElement(), -1); 7455 if (element.hasEffectivePeriod()) 7456 composePeriod(t, "Library", "effectivePeriod", element.getEffectivePeriod(), -1); 7457 for (int i = 0; i < element.getUseContext().size(); i++) 7458 composeUsageContext(t, "Library", "useContext", element.getUseContext().get(i), i); 7459 for (int i = 0; i < element.getJurisdiction().size(); i++) 7460 composeCodeableConcept(t, "Library", "jurisdiction", element.getJurisdiction().get(i), i); 7461 for (int i = 0; i < element.getTopic().size(); i++) 7462 composeCodeableConcept(t, "Library", "topic", element.getTopic().get(i), i); 7463 for (int i = 0; i < element.getContributor().size(); i++) 7464 composeContributor(t, "Library", "contributor", element.getContributor().get(i), i); 7465 for (int i = 0; i < element.getContact().size(); i++) 7466 composeContactDetail(t, "Library", "contact", element.getContact().get(i), i); 7467 if (element.hasCopyrightElement()) 7468 composeMarkdown(t, "Library", "copyright", element.getCopyrightElement(), -1); 7469 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 7470 composeRelatedArtifact(t, "Library", "relatedArtifact", element.getRelatedArtifact().get(i), i); 7471 for (int i = 0; i < element.getParameter().size(); i++) 7472 composeParameterDefinition(t, "Library", "parameter", element.getParameter().get(i), i); 7473 for (int i = 0; i < element.getDataRequirement().size(); i++) 7474 composeDataRequirement(t, "Library", "dataRequirement", element.getDataRequirement().get(i), i); 7475 for (int i = 0; i < element.getContent().size(); i++) 7476 composeAttachment(t, "Library", "content", element.getContent().get(i), i); 7477 } 7478 7479 protected void composeLinkage(Complex parent, String parentType, String name, Linkage element, int index) { 7480 if (element == null) 7481 return; 7482 Complex t; 7483 if (Utilities.noString(parentType)) 7484 t = parent; 7485 else { 7486 t = parent.predicate("fhir:"+parentType+'.'+name); 7487 } 7488 composeDomainResource(t, "Linkage", name, element, index); 7489 if (element.hasActiveElement()) 7490 composeBoolean(t, "Linkage", "active", element.getActiveElement(), -1); 7491 if (element.hasAuthor()) 7492 composeReference(t, "Linkage", "author", element.getAuthor(), -1); 7493 for (int i = 0; i < element.getItem().size(); i++) 7494 composeLinkageLinkageItemComponent(t, "Linkage", "item", element.getItem().get(i), i); 7495 } 7496 7497 protected void composeLinkageLinkageItemComponent(Complex parent, String parentType, String name, Linkage.LinkageItemComponent element, int index) { 7498 if (element == null) 7499 return; 7500 Complex t; 7501 if (Utilities.noString(parentType)) 7502 t = parent; 7503 else { 7504 t = parent.predicate("fhir:"+parentType+'.'+name); 7505 } 7506 composeBackboneElement(t, "item", name, element, index); 7507 if (element.hasTypeElement()) 7508 composeEnum(t, "Linkage", "type", element.getTypeElement(), -1); 7509 if (element.hasResource()) 7510 composeReference(t, "Linkage", "resource", element.getResource(), -1); 7511 } 7512 7513 protected void composeListResource(Complex parent, String parentType, String name, ListResource element, int index) { 7514 if (element == null) 7515 return; 7516 Complex t; 7517 if (Utilities.noString(parentType)) 7518 t = parent; 7519 else { 7520 t = parent.predicate("fhir:"+parentType+'.'+name); 7521 } 7522 composeDomainResource(t, "List", name, element, index); 7523 for (int i = 0; i < element.getIdentifier().size(); i++) 7524 composeIdentifier(t, "List", "identifier", element.getIdentifier().get(i), i); 7525 if (element.hasStatusElement()) 7526 composeEnum(t, "List", "status", element.getStatusElement(), -1); 7527 if (element.hasModeElement()) 7528 composeEnum(t, "List", "mode", element.getModeElement(), -1); 7529 if (element.hasTitleElement()) 7530 composeString(t, "List", "title", element.getTitleElement(), -1); 7531 if (element.hasCode()) 7532 composeCodeableConcept(t, "List", "code", element.getCode(), -1); 7533 if (element.hasSubject()) 7534 composeReference(t, "List", "subject", element.getSubject(), -1); 7535 if (element.hasEncounter()) 7536 composeReference(t, "List", "encounter", element.getEncounter(), -1); 7537 if (element.hasDateElement()) 7538 composeDateTime(t, "List", "date", element.getDateElement(), -1); 7539 if (element.hasSource()) 7540 composeReference(t, "List", "source", element.getSource(), -1); 7541 if (element.hasOrderedBy()) 7542 composeCodeableConcept(t, "List", "orderedBy", element.getOrderedBy(), -1); 7543 for (int i = 0; i < element.getNote().size(); i++) 7544 composeAnnotation(t, "List", "note", element.getNote().get(i), i); 7545 for (int i = 0; i < element.getEntry().size(); i++) 7546 composeListResourceListEntryComponent(t, "List", "entry", element.getEntry().get(i), i); 7547 if (element.hasEmptyReason()) 7548 composeCodeableConcept(t, "List", "emptyReason", element.getEmptyReason(), -1); 7549 } 7550 7551 protected void composeListResourceListEntryComponent(Complex parent, String parentType, String name, ListResource.ListEntryComponent element, int index) { 7552 if (element == null) 7553 return; 7554 Complex t; 7555 if (Utilities.noString(parentType)) 7556 t = parent; 7557 else { 7558 t = parent.predicate("fhir:"+parentType+'.'+name); 7559 } 7560 composeBackboneElement(t, "entry", name, element, index); 7561 if (element.hasFlag()) 7562 composeCodeableConcept(t, "List", "flag", element.getFlag(), -1); 7563 if (element.hasDeletedElement()) 7564 composeBoolean(t, "List", "deleted", element.getDeletedElement(), -1); 7565 if (element.hasDateElement()) 7566 composeDateTime(t, "List", "date", element.getDateElement(), -1); 7567 if (element.hasItem()) 7568 composeReference(t, "List", "item", element.getItem(), -1); 7569 } 7570 7571 protected void composeLocation(Complex parent, String parentType, String name, Location 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 composeDomainResource(t, "Location", name, element, index); 7581 for (int i = 0; i < element.getIdentifier().size(); i++) 7582 composeIdentifier(t, "Location", "identifier", element.getIdentifier().get(i), i); 7583 if (element.hasStatusElement()) 7584 composeEnum(t, "Location", "status", element.getStatusElement(), -1); 7585 if (element.hasOperationalStatus()) 7586 composeCoding(t, "Location", "operationalStatus", element.getOperationalStatus(), -1); 7587 if (element.hasNameElement()) 7588 composeString(t, "Location", "name", element.getNameElement(), -1); 7589 for (int i = 0; i < element.getAlias().size(); i++) 7590 composeString(t, "Location", "alias", element.getAlias().get(i), i); 7591 if (element.hasDescriptionElement()) 7592 composeString(t, "Location", "description", element.getDescriptionElement(), -1); 7593 if (element.hasModeElement()) 7594 composeEnum(t, "Location", "mode", element.getModeElement(), -1); 7595 if (element.hasType()) 7596 composeCodeableConcept(t, "Location", "type", element.getType(), -1); 7597 for (int i = 0; i < element.getTelecom().size(); i++) 7598 composeContactPoint(t, "Location", "telecom", element.getTelecom().get(i), i); 7599 if (element.hasAddress()) 7600 composeAddress(t, "Location", "address", element.getAddress(), -1); 7601 if (element.hasPhysicalType()) 7602 composeCodeableConcept(t, "Location", "physicalType", element.getPhysicalType(), -1); 7603 if (element.hasPosition()) 7604 composeLocationLocationPositionComponent(t, "Location", "position", element.getPosition(), -1); 7605 if (element.hasManagingOrganization()) 7606 composeReference(t, "Location", "managingOrganization", element.getManagingOrganization(), -1); 7607 if (element.hasPartOf()) 7608 composeReference(t, "Location", "partOf", element.getPartOf(), -1); 7609 for (int i = 0; i < element.getEndpoint().size(); i++) 7610 composeReference(t, "Location", "endpoint", element.getEndpoint().get(i), i); 7611 } 7612 7613 protected void composeLocationLocationPositionComponent(Complex parent, String parentType, String name, Location.LocationPositionComponent element, int index) { 7614 if (element == null) 7615 return; 7616 Complex t; 7617 if (Utilities.noString(parentType)) 7618 t = parent; 7619 else { 7620 t = parent.predicate("fhir:"+parentType+'.'+name); 7621 } 7622 composeBackboneElement(t, "position", name, element, index); 7623 if (element.hasLongitudeElement()) 7624 composeDecimal(t, "Location", "longitude", element.getLongitudeElement(), -1); 7625 if (element.hasLatitudeElement()) 7626 composeDecimal(t, "Location", "latitude", element.getLatitudeElement(), -1); 7627 if (element.hasAltitudeElement()) 7628 composeDecimal(t, "Location", "altitude", element.getAltitudeElement(), -1); 7629 } 7630 7631 protected void composeMeasure(Complex parent, String parentType, String name, Measure element, int index) { 7632 if (element == null) 7633 return; 7634 Complex t; 7635 if (Utilities.noString(parentType)) 7636 t = parent; 7637 else { 7638 t = parent.predicate("fhir:"+parentType+'.'+name); 7639 } 7640 composeDomainResource(t, "Measure", name, element, index); 7641 if (element.hasUrlElement()) 7642 composeUri(t, "Measure", "url", element.getUrlElement(), -1); 7643 for (int i = 0; i < element.getIdentifier().size(); i++) 7644 composeIdentifier(t, "Measure", "identifier", element.getIdentifier().get(i), i); 7645 if (element.hasVersionElement()) 7646 composeString(t, "Measure", "version", element.getVersionElement(), -1); 7647 if (element.hasNameElement()) 7648 composeString(t, "Measure", "name", element.getNameElement(), -1); 7649 if (element.hasTitleElement()) 7650 composeString(t, "Measure", "title", element.getTitleElement(), -1); 7651 if (element.hasStatusElement()) 7652 composeEnum(t, "Measure", "status", element.getStatusElement(), -1); 7653 if (element.hasExperimentalElement()) 7654 composeBoolean(t, "Measure", "experimental", element.getExperimentalElement(), -1); 7655 if (element.hasDateElement()) 7656 composeDateTime(t, "Measure", "date", element.getDateElement(), -1); 7657 if (element.hasPublisherElement()) 7658 composeString(t, "Measure", "publisher", element.getPublisherElement(), -1); 7659 if (element.hasDescriptionElement()) 7660 composeMarkdown(t, "Measure", "description", element.getDescriptionElement(), -1); 7661 if (element.hasPurposeElement()) 7662 composeMarkdown(t, "Measure", "purpose", element.getPurposeElement(), -1); 7663 if (element.hasUsageElement()) 7664 composeString(t, "Measure", "usage", element.getUsageElement(), -1); 7665 if (element.hasApprovalDateElement()) 7666 composeDate(t, "Measure", "approvalDate", element.getApprovalDateElement(), -1); 7667 if (element.hasLastReviewDateElement()) 7668 composeDate(t, "Measure", "lastReviewDate", element.getLastReviewDateElement(), -1); 7669 if (element.hasEffectivePeriod()) 7670 composePeriod(t, "Measure", "effectivePeriod", element.getEffectivePeriod(), -1); 7671 for (int i = 0; i < element.getUseContext().size(); i++) 7672 composeUsageContext(t, "Measure", "useContext", element.getUseContext().get(i), i); 7673 for (int i = 0; i < element.getJurisdiction().size(); i++) 7674 composeCodeableConcept(t, "Measure", "jurisdiction", element.getJurisdiction().get(i), i); 7675 for (int i = 0; i < element.getTopic().size(); i++) 7676 composeCodeableConcept(t, "Measure", "topic", element.getTopic().get(i), i); 7677 for (int i = 0; i < element.getContributor().size(); i++) 7678 composeContributor(t, "Measure", "contributor", element.getContributor().get(i), i); 7679 for (int i = 0; i < element.getContact().size(); i++) 7680 composeContactDetail(t, "Measure", "contact", element.getContact().get(i), i); 7681 if (element.hasCopyrightElement()) 7682 composeMarkdown(t, "Measure", "copyright", element.getCopyrightElement(), -1); 7683 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 7684 composeRelatedArtifact(t, "Measure", "relatedArtifact", element.getRelatedArtifact().get(i), i); 7685 for (int i = 0; i < element.getLibrary().size(); i++) 7686 composeReference(t, "Measure", "library", element.getLibrary().get(i), i); 7687 if (element.hasDisclaimerElement()) 7688 composeMarkdown(t, "Measure", "disclaimer", element.getDisclaimerElement(), -1); 7689 if (element.hasScoring()) 7690 composeCodeableConcept(t, "Measure", "scoring", element.getScoring(), -1); 7691 if (element.hasCompositeScoring()) 7692 composeCodeableConcept(t, "Measure", "compositeScoring", element.getCompositeScoring(), -1); 7693 for (int i = 0; i < element.getType().size(); i++) 7694 composeCodeableConcept(t, "Measure", "type", element.getType().get(i), i); 7695 if (element.hasRiskAdjustmentElement()) 7696 composeString(t, "Measure", "riskAdjustment", element.getRiskAdjustmentElement(), -1); 7697 if (element.hasRateAggregationElement()) 7698 composeString(t, "Measure", "rateAggregation", element.getRateAggregationElement(), -1); 7699 if (element.hasRationaleElement()) 7700 composeMarkdown(t, "Measure", "rationale", element.getRationaleElement(), -1); 7701 if (element.hasClinicalRecommendationStatementElement()) 7702 composeMarkdown(t, "Measure", "clinicalRecommendationStatement", element.getClinicalRecommendationStatementElement(), -1); 7703 if (element.hasImprovementNotationElement()) 7704 composeString(t, "Measure", "improvementNotation", element.getImprovementNotationElement(), -1); 7705 for (int i = 0; i < element.getDefinition().size(); i++) 7706 composeMarkdown(t, "Measure", "definition", element.getDefinition().get(i), i); 7707 if (element.hasGuidanceElement()) 7708 composeMarkdown(t, "Measure", "guidance", element.getGuidanceElement(), -1); 7709 if (element.hasSetElement()) 7710 composeString(t, "Measure", "set", element.getSetElement(), -1); 7711 for (int i = 0; i < element.getGroup().size(); i++) 7712 composeMeasureMeasureGroupComponent(t, "Measure", "group", element.getGroup().get(i), i); 7713 for (int i = 0; i < element.getSupplementalData().size(); i++) 7714 composeMeasureMeasureSupplementalDataComponent(t, "Measure", "supplementalData", element.getSupplementalData().get(i), i); 7715 } 7716 7717 protected void composeMeasureMeasureGroupComponent(Complex parent, String parentType, String name, Measure.MeasureGroupComponent element, int index) { 7718 if (element == null) 7719 return; 7720 Complex t; 7721 if (Utilities.noString(parentType)) 7722 t = parent; 7723 else { 7724 t = parent.predicate("fhir:"+parentType+'.'+name); 7725 } 7726 composeBackboneElement(t, "group", name, element, index); 7727 if (element.hasIdentifier()) 7728 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7729 if (element.hasNameElement()) 7730 composeString(t, "Measure", "name", element.getNameElement(), -1); 7731 if (element.hasDescriptionElement()) 7732 composeString(t, "Measure", "description", element.getDescriptionElement(), -1); 7733 for (int i = 0; i < element.getPopulation().size(); i++) 7734 composeMeasureMeasureGroupPopulationComponent(t, "Measure", "population", element.getPopulation().get(i), i); 7735 for (int i = 0; i < element.getStratifier().size(); i++) 7736 composeMeasureMeasureGroupStratifierComponent(t, "Measure", "stratifier", element.getStratifier().get(i), i); 7737 } 7738 7739 protected void composeMeasureMeasureGroupPopulationComponent(Complex parent, String parentType, String name, Measure.MeasureGroupPopulationComponent element, int index) { 7740 if (element == null) 7741 return; 7742 Complex t; 7743 if (Utilities.noString(parentType)) 7744 t = parent; 7745 else { 7746 t = parent.predicate("fhir:"+parentType+'.'+name); 7747 } 7748 composeBackboneElement(t, "population", name, element, index); 7749 if (element.hasIdentifier()) 7750 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7751 if (element.hasCode()) 7752 composeCodeableConcept(t, "Measure", "code", element.getCode(), -1); 7753 if (element.hasNameElement()) 7754 composeString(t, "Measure", "name", element.getNameElement(), -1); 7755 if (element.hasDescriptionElement()) 7756 composeString(t, "Measure", "description", element.getDescriptionElement(), -1); 7757 if (element.hasCriteriaElement()) 7758 composeString(t, "Measure", "criteria", element.getCriteriaElement(), -1); 7759 } 7760 7761 protected void composeMeasureMeasureGroupStratifierComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponent element, int index) { 7762 if (element == null) 7763 return; 7764 Complex t; 7765 if (Utilities.noString(parentType)) 7766 t = parent; 7767 else { 7768 t = parent.predicate("fhir:"+parentType+'.'+name); 7769 } 7770 composeBackboneElement(t, "stratifier", name, element, index); 7771 if (element.hasIdentifier()) 7772 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7773 if (element.hasCriteriaElement()) 7774 composeString(t, "Measure", "criteria", element.getCriteriaElement(), -1); 7775 if (element.hasPathElement()) 7776 composeString(t, "Measure", "path", element.getPathElement(), -1); 7777 } 7778 7779 protected void composeMeasureMeasureSupplementalDataComponent(Complex parent, String parentType, String name, Measure.MeasureSupplementalDataComponent element, int index) { 7780 if (element == null) 7781 return; 7782 Complex t; 7783 if (Utilities.noString(parentType)) 7784 t = parent; 7785 else { 7786 t = parent.predicate("fhir:"+parentType+'.'+name); 7787 } 7788 composeBackboneElement(t, "supplementalData", name, element, index); 7789 if (element.hasIdentifier()) 7790 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7791 for (int i = 0; i < element.getUsage().size(); i++) 7792 composeCodeableConcept(t, "Measure", "usage", element.getUsage().get(i), i); 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 composeMeasureReport(Complex parent, String parentType, String name, MeasureReport 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 composeDomainResource(t, "MeasureReport", name, element, index); 7809 if (element.hasIdentifier()) 7810 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7811 if (element.hasStatusElement()) 7812 composeEnum(t, "MeasureReport", "status", element.getStatusElement(), -1); 7813 if (element.hasTypeElement()) 7814 composeEnum(t, "MeasureReport", "type", element.getTypeElement(), -1); 7815 if (element.hasMeasure()) 7816 composeReference(t, "MeasureReport", "measure", element.getMeasure(), -1); 7817 if (element.hasPatient()) 7818 composeReference(t, "MeasureReport", "patient", element.getPatient(), -1); 7819 if (element.hasDateElement()) 7820 composeDateTime(t, "MeasureReport", "date", element.getDateElement(), -1); 7821 if (element.hasReportingOrganization()) 7822 composeReference(t, "MeasureReport", "reportingOrganization", element.getReportingOrganization(), -1); 7823 if (element.hasPeriod()) 7824 composePeriod(t, "MeasureReport", "period", element.getPeriod(), -1); 7825 for (int i = 0; i < element.getGroup().size(); i++) 7826 composeMeasureReportMeasureReportGroupComponent(t, "MeasureReport", "group", element.getGroup().get(i), i); 7827 if (element.hasEvaluatedResources()) 7828 composeReference(t, "MeasureReport", "evaluatedResources", element.getEvaluatedResources(), -1); 7829 } 7830 7831 protected void composeMeasureReportMeasureReportGroupComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupComponent element, int index) { 7832 if (element == null) 7833 return; 7834 Complex t; 7835 if (Utilities.noString(parentType)) 7836 t = parent; 7837 else { 7838 t = parent.predicate("fhir:"+parentType+'.'+name); 7839 } 7840 composeBackboneElement(t, "group", name, element, index); 7841 if (element.hasIdentifier()) 7842 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7843 for (int i = 0; i < element.getPopulation().size(); i++) 7844 composeMeasureReportMeasureReportGroupPopulationComponent(t, "MeasureReport", "population", element.getPopulation().get(i), i); 7845 if (element.hasMeasureScoreElement()) 7846 composeDecimal(t, "MeasureReport", "measureScore", element.getMeasureScoreElement(), -1); 7847 for (int i = 0; i < element.getStratifier().size(); i++) 7848 composeMeasureReportMeasureReportGroupStratifierComponent(t, "MeasureReport", "stratifier", element.getStratifier().get(i), i); 7849 } 7850 7851 protected void composeMeasureReportMeasureReportGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupPopulationComponent 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, "population", name, element, index); 7861 if (element.hasIdentifier()) 7862 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7863 if (element.hasCode()) 7864 composeCodeableConcept(t, "MeasureReport", "code", element.getCode(), -1); 7865 if (element.hasCountElement()) 7866 composeInteger(t, "MeasureReport", "count", element.getCountElement(), -1); 7867 if (element.hasPatients()) 7868 composeReference(t, "MeasureReport", "patients", element.getPatients(), -1); 7869 } 7870 7871 protected void composeMeasureReportMeasureReportGroupStratifierComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupStratifierComponent 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, "stratifier", name, element, index); 7881 if (element.hasIdentifier()) 7882 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7883 for (int i = 0; i < element.getStratum().size(); i++) 7884 composeMeasureReportStratifierGroupComponent(t, "MeasureReport", "stratum", element.getStratum().get(i), i); 7885 } 7886 7887 protected void composeMeasureReportStratifierGroupComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupComponent element, int index) { 7888 if (element == null) 7889 return; 7890 Complex t; 7891 if (Utilities.noString(parentType)) 7892 t = parent; 7893 else { 7894 t = parent.predicate("fhir:"+parentType+'.'+name); 7895 } 7896 composeBackboneElement(t, "stratum", name, element, index); 7897 if (element.hasValueElement()) 7898 composeString(t, "MeasureReport", "value", element.getValueElement(), -1); 7899 for (int i = 0; i < element.getPopulation().size(); i++) 7900 composeMeasureReportStratifierGroupPopulationComponent(t, "MeasureReport", "population", element.getPopulation().get(i), i); 7901 if (element.hasMeasureScoreElement()) 7902 composeDecimal(t, "MeasureReport", "measureScore", element.getMeasureScoreElement(), -1); 7903 } 7904 7905 protected void composeMeasureReportStratifierGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupPopulationComponent element, int index) { 7906 if (element == null) 7907 return; 7908 Complex t; 7909 if (Utilities.noString(parentType)) 7910 t = parent; 7911 else { 7912 t = parent.predicate("fhir:"+parentType+'.'+name); 7913 } 7914 composeBackboneElement(t, "population", name, element, index); 7915 if (element.hasIdentifier()) 7916 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7917 if (element.hasCode()) 7918 composeCodeableConcept(t, "MeasureReport", "code", element.getCode(), -1); 7919 if (element.hasCountElement()) 7920 composeInteger(t, "MeasureReport", "count", element.getCountElement(), -1); 7921 if (element.hasPatients()) 7922 composeReference(t, "MeasureReport", "patients", element.getPatients(), -1); 7923 } 7924 7925 protected void composeMedia(Complex parent, String parentType, String name, Media 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 composeDomainResource(t, "Media", name, element, index); 7935 for (int i = 0; i < element.getIdentifier().size(); i++) 7936 composeIdentifier(t, "Media", "identifier", element.getIdentifier().get(i), i); 7937 for (int i = 0; i < element.getBasedOn().size(); i++) 7938 composeReference(t, "Media", "basedOn", element.getBasedOn().get(i), i); 7939 if (element.hasTypeElement()) 7940 composeEnum(t, "Media", "type", element.getTypeElement(), -1); 7941 if (element.hasSubtype()) 7942 composeCodeableConcept(t, "Media", "subtype", element.getSubtype(), -1); 7943 if (element.hasView()) 7944 composeCodeableConcept(t, "Media", "view", element.getView(), -1); 7945 if (element.hasSubject()) 7946 composeReference(t, "Media", "subject", element.getSubject(), -1); 7947 if (element.hasContext()) 7948 composeReference(t, "Media", "context", element.getContext(), -1); 7949 if (element.hasOccurrence()) 7950 composeType(t, "Media", "occurrence", element.getOccurrence(), -1); 7951 if (element.hasOperator()) 7952 composeReference(t, "Media", "operator", element.getOperator(), -1); 7953 for (int i = 0; i < element.getReasonCode().size(); i++) 7954 composeCodeableConcept(t, "Media", "reasonCode", element.getReasonCode().get(i), i); 7955 if (element.hasBodySite()) 7956 composeCodeableConcept(t, "Media", "bodySite", element.getBodySite(), -1); 7957 if (element.hasDevice()) 7958 composeReference(t, "Media", "device", element.getDevice(), -1); 7959 if (element.hasHeightElement()) 7960 composePositiveInt(t, "Media", "height", element.getHeightElement(), -1); 7961 if (element.hasWidthElement()) 7962 composePositiveInt(t, "Media", "width", element.getWidthElement(), -1); 7963 if (element.hasFramesElement()) 7964 composePositiveInt(t, "Media", "frames", element.getFramesElement(), -1); 7965 if (element.hasDurationElement()) 7966 composeUnsignedInt(t, "Media", "duration", element.getDurationElement(), -1); 7967 if (element.hasContent()) 7968 composeAttachment(t, "Media", "content", element.getContent(), -1); 7969 for (int i = 0; i < element.getNote().size(); i++) 7970 composeAnnotation(t, "Media", "note", element.getNote().get(i), i); 7971 } 7972 7973 protected void composeMedication(Complex parent, String parentType, String name, Medication element, int index) { 7974 if (element == null) 7975 return; 7976 Complex t; 7977 if (Utilities.noString(parentType)) 7978 t = parent; 7979 else { 7980 t = parent.predicate("fhir:"+parentType+'.'+name); 7981 } 7982 composeDomainResource(t, "Medication", name, element, index); 7983 if (element.hasCode()) 7984 composeCodeableConcept(t, "Medication", "code", element.getCode(), -1); 7985 if (element.hasStatusElement()) 7986 composeEnum(t, "Medication", "status", element.getStatusElement(), -1); 7987 if (element.hasIsBrandElement()) 7988 composeBoolean(t, "Medication", "isBrand", element.getIsBrandElement(), -1); 7989 if (element.hasIsOverTheCounterElement()) 7990 composeBoolean(t, "Medication", "isOverTheCounter", element.getIsOverTheCounterElement(), -1); 7991 if (element.hasManufacturer()) 7992 composeReference(t, "Medication", "manufacturer", element.getManufacturer(), -1); 7993 if (element.hasForm()) 7994 composeCodeableConcept(t, "Medication", "form", element.getForm(), -1); 7995 for (int i = 0; i < element.getIngredient().size(); i++) 7996 composeMedicationMedicationIngredientComponent(t, "Medication", "ingredient", element.getIngredient().get(i), i); 7997 if (element.hasPackage()) 7998 composeMedicationMedicationPackageComponent(t, "Medication", "package", element.getPackage(), -1); 7999 for (int i = 0; i < element.getImage().size(); i++) 8000 composeAttachment(t, "Medication", "image", element.getImage().get(i), i); 8001 } 8002 8003 protected void composeMedicationMedicationIngredientComponent(Complex parent, String parentType, String name, Medication.MedicationIngredientComponent element, int index) { 8004 if (element == null) 8005 return; 8006 Complex t; 8007 if (Utilities.noString(parentType)) 8008 t = parent; 8009 else { 8010 t = parent.predicate("fhir:"+parentType+'.'+name); 8011 } 8012 composeBackboneElement(t, "ingredient", name, element, index); 8013 if (element.hasItem()) 8014 composeType(t, "Medication", "item", element.getItem(), -1); 8015 if (element.hasIsActiveElement()) 8016 composeBoolean(t, "Medication", "isActive", element.getIsActiveElement(), -1); 8017 if (element.hasAmount()) 8018 composeRatio(t, "Medication", "amount", element.getAmount(), -1); 8019 } 8020 8021 protected void composeMedicationMedicationPackageComponent(Complex parent, String parentType, String name, Medication.MedicationPackageComponent element, int index) { 8022 if (element == null) 8023 return; 8024 Complex t; 8025 if (Utilities.noString(parentType)) 8026 t = parent; 8027 else { 8028 t = parent.predicate("fhir:"+parentType+'.'+name); 8029 } 8030 composeBackboneElement(t, "package", name, element, index); 8031 if (element.hasContainer()) 8032 composeCodeableConcept(t, "Medication", "container", element.getContainer(), -1); 8033 for (int i = 0; i < element.getContent().size(); i++) 8034 composeMedicationMedicationPackageContentComponent(t, "Medication", "content", element.getContent().get(i), i); 8035 for (int i = 0; i < element.getBatch().size(); i++) 8036 composeMedicationMedicationPackageBatchComponent(t, "Medication", "batch", element.getBatch().get(i), i); 8037 } 8038 8039 protected void composeMedicationMedicationPackageContentComponent(Complex parent, String parentType, String name, Medication.MedicationPackageContentComponent element, int index) { 8040 if (element == null) 8041 return; 8042 Complex t; 8043 if (Utilities.noString(parentType)) 8044 t = parent; 8045 else { 8046 t = parent.predicate("fhir:"+parentType+'.'+name); 8047 } 8048 composeBackboneElement(t, "content", name, element, index); 8049 if (element.hasItem()) 8050 composeType(t, "Medication", "item", element.getItem(), -1); 8051 if (element.hasAmount()) 8052 composeQuantity(t, "Medication", "amount", element.getAmount(), -1); 8053 } 8054 8055 protected void composeMedicationMedicationPackageBatchComponent(Complex parent, String parentType, String name, Medication.MedicationPackageBatchComponent element, int index) { 8056 if (element == null) 8057 return; 8058 Complex t; 8059 if (Utilities.noString(parentType)) 8060 t = parent; 8061 else { 8062 t = parent.predicate("fhir:"+parentType+'.'+name); 8063 } 8064 composeBackboneElement(t, "batch", name, element, index); 8065 if (element.hasLotNumberElement()) 8066 composeString(t, "Medication", "lotNumber", element.getLotNumberElement(), -1); 8067 if (element.hasExpirationDateElement()) 8068 composeDateTime(t, "Medication", "expirationDate", element.getExpirationDateElement(), -1); 8069 } 8070 8071 protected void composeMedicationAdministration(Complex parent, String parentType, String name, MedicationAdministration element, int index) { 8072 if (element == null) 8073 return; 8074 Complex t; 8075 if (Utilities.noString(parentType)) 8076 t = parent; 8077 else { 8078 t = parent.predicate("fhir:"+parentType+'.'+name); 8079 } 8080 composeDomainResource(t, "MedicationAdministration", name, element, index); 8081 for (int i = 0; i < element.getIdentifier().size(); i++) 8082 composeIdentifier(t, "MedicationAdministration", "identifier", element.getIdentifier().get(i), i); 8083 for (int i = 0; i < element.getDefinition().size(); i++) 8084 composeReference(t, "MedicationAdministration", "definition", element.getDefinition().get(i), i); 8085 for (int i = 0; i < element.getPartOf().size(); i++) 8086 composeReference(t, "MedicationAdministration", "partOf", element.getPartOf().get(i), i); 8087 if (element.hasStatusElement()) 8088 composeEnum(t, "MedicationAdministration", "status", element.getStatusElement(), -1); 8089 if (element.hasCategory()) 8090 composeCodeableConcept(t, "MedicationAdministration", "category", element.getCategory(), -1); 8091 if (element.hasMedication()) 8092 composeType(t, "MedicationAdministration", "medication", element.getMedication(), -1); 8093 if (element.hasSubject()) 8094 composeReference(t, "MedicationAdministration", "subject", element.getSubject(), -1); 8095 if (element.hasContext()) 8096 composeReference(t, "MedicationAdministration", "context", element.getContext(), -1); 8097 for (int i = 0; i < element.getSupportingInformation().size(); i++) 8098 composeReference(t, "MedicationAdministration", "supportingInformation", element.getSupportingInformation().get(i), i); 8099 if (element.hasEffective()) 8100 composeType(t, "MedicationAdministration", "effective", element.getEffective(), -1); 8101 for (int i = 0; i < element.getPerformer().size(); i++) 8102 composeMedicationAdministrationMedicationAdministrationPerformerComponent(t, "MedicationAdministration", "performer", element.getPerformer().get(i), i); 8103 if (element.hasNotGivenElement()) 8104 composeBoolean(t, "MedicationAdministration", "notGiven", element.getNotGivenElement(), -1); 8105 for (int i = 0; i < element.getReasonNotGiven().size(); i++) 8106 composeCodeableConcept(t, "MedicationAdministration", "reasonNotGiven", element.getReasonNotGiven().get(i), i); 8107 for (int i = 0; i < element.getReasonCode().size(); i++) 8108 composeCodeableConcept(t, "MedicationAdministration", "reasonCode", element.getReasonCode().get(i), i); 8109 for (int i = 0; i < element.getReasonReference().size(); i++) 8110 composeReference(t, "MedicationAdministration", "reasonReference", element.getReasonReference().get(i), i); 8111 if (element.hasPrescription()) 8112 composeReference(t, "MedicationAdministration", "prescription", element.getPrescription(), -1); 8113 for (int i = 0; i < element.getDevice().size(); i++) 8114 composeReference(t, "MedicationAdministration", "device", element.getDevice().get(i), i); 8115 for (int i = 0; i < element.getNote().size(); i++) 8116 composeAnnotation(t, "MedicationAdministration", "note", element.getNote().get(i), i); 8117 if (element.hasDosage()) 8118 composeMedicationAdministrationMedicationAdministrationDosageComponent(t, "MedicationAdministration", "dosage", element.getDosage(), -1); 8119 for (int i = 0; i < element.getEventHistory().size(); i++) 8120 composeReference(t, "MedicationAdministration", "eventHistory", element.getEventHistory().get(i), i); 8121 } 8122 8123 protected void composeMedicationAdministrationMedicationAdministrationPerformerComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationPerformerComponent element, int index) { 8124 if (element == null) 8125 return; 8126 Complex t; 8127 if (Utilities.noString(parentType)) 8128 t = parent; 8129 else { 8130 t = parent.predicate("fhir:"+parentType+'.'+name); 8131 } 8132 composeBackboneElement(t, "performer", name, element, index); 8133 if (element.hasActor()) 8134 composeReference(t, "MedicationAdministration", "actor", element.getActor(), -1); 8135 if (element.hasOnBehalfOf()) 8136 composeReference(t, "MedicationAdministration", "onBehalfOf", element.getOnBehalfOf(), -1); 8137 } 8138 8139 protected void composeMedicationAdministrationMedicationAdministrationDosageComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationDosageComponent element, int index) { 8140 if (element == null) 8141 return; 8142 Complex t; 8143 if (Utilities.noString(parentType)) 8144 t = parent; 8145 else { 8146 t = parent.predicate("fhir:"+parentType+'.'+name); 8147 } 8148 composeBackboneElement(t, "dosage", name, element, index); 8149 if (element.hasTextElement()) 8150 composeString(t, "MedicationAdministration", "text", element.getTextElement(), -1); 8151 if (element.hasSite()) 8152 composeCodeableConcept(t, "MedicationAdministration", "site", element.getSite(), -1); 8153 if (element.hasRoute()) 8154 composeCodeableConcept(t, "MedicationAdministration", "route", element.getRoute(), -1); 8155 if (element.hasMethod()) 8156 composeCodeableConcept(t, "MedicationAdministration", "method", element.getMethod(), -1); 8157 if (element.hasDose()) 8158 composeQuantity(t, "MedicationAdministration", "dose", element.getDose(), -1); 8159 if (element.hasRate()) 8160 composeType(t, "MedicationAdministration", "rate", element.getRate(), -1); 8161 } 8162 8163 protected void composeMedicationDispense(Complex parent, String parentType, String name, MedicationDispense element, int index) { 8164 if (element == null) 8165 return; 8166 Complex t; 8167 if (Utilities.noString(parentType)) 8168 t = parent; 8169 else { 8170 t = parent.predicate("fhir:"+parentType+'.'+name); 8171 } 8172 composeDomainResource(t, "MedicationDispense", name, element, index); 8173 for (int i = 0; i < element.getIdentifier().size(); i++) 8174 composeIdentifier(t, "MedicationDispense", "identifier", element.getIdentifier().get(i), i); 8175 for (int i = 0; i < element.getPartOf().size(); i++) 8176 composeReference(t, "MedicationDispense", "partOf", element.getPartOf().get(i), i); 8177 if (element.hasStatusElement()) 8178 composeEnum(t, "MedicationDispense", "status", element.getStatusElement(), -1); 8179 if (element.hasCategory()) 8180 composeCodeableConcept(t, "MedicationDispense", "category", element.getCategory(), -1); 8181 if (element.hasMedication()) 8182 composeType(t, "MedicationDispense", "medication", element.getMedication(), -1); 8183 if (element.hasSubject()) 8184 composeReference(t, "MedicationDispense", "subject", element.getSubject(), -1); 8185 if (element.hasContext()) 8186 composeReference(t, "MedicationDispense", "context", element.getContext(), -1); 8187 for (int i = 0; i < element.getSupportingInformation().size(); i++) 8188 composeReference(t, "MedicationDispense", "supportingInformation", element.getSupportingInformation().get(i), i); 8189 for (int i = 0; i < element.getPerformer().size(); i++) 8190 composeMedicationDispenseMedicationDispensePerformerComponent(t, "MedicationDispense", "performer", element.getPerformer().get(i), i); 8191 for (int i = 0; i < element.getAuthorizingPrescription().size(); i++) 8192 composeReference(t, "MedicationDispense", "authorizingPrescription", element.getAuthorizingPrescription().get(i), i); 8193 if (element.hasType()) 8194 composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1); 8195 if (element.hasQuantity()) 8196 composeQuantity(t, "MedicationDispense", "quantity", element.getQuantity(), -1); 8197 if (element.hasDaysSupply()) 8198 composeQuantity(t, "MedicationDispense", "daysSupply", element.getDaysSupply(), -1); 8199 if (element.hasWhenPreparedElement()) 8200 composeDateTime(t, "MedicationDispense", "whenPrepared", element.getWhenPreparedElement(), -1); 8201 if (element.hasWhenHandedOverElement()) 8202 composeDateTime(t, "MedicationDispense", "whenHandedOver", element.getWhenHandedOverElement(), -1); 8203 if (element.hasDestination()) 8204 composeReference(t, "MedicationDispense", "destination", element.getDestination(), -1); 8205 for (int i = 0; i < element.getReceiver().size(); i++) 8206 composeReference(t, "MedicationDispense", "receiver", element.getReceiver().get(i), i); 8207 for (int i = 0; i < element.getNote().size(); i++) 8208 composeAnnotation(t, "MedicationDispense", "note", element.getNote().get(i), i); 8209 for (int i = 0; i < element.getDosageInstruction().size(); i++) 8210 composeDosage(t, "MedicationDispense", "dosageInstruction", element.getDosageInstruction().get(i), i); 8211 if (element.hasSubstitution()) 8212 composeMedicationDispenseMedicationDispenseSubstitutionComponent(t, "MedicationDispense", "substitution", element.getSubstitution(), -1); 8213 for (int i = 0; i < element.getDetectedIssue().size(); i++) 8214 composeReference(t, "MedicationDispense", "detectedIssue", element.getDetectedIssue().get(i), i); 8215 if (element.hasNotDoneElement()) 8216 composeBoolean(t, "MedicationDispense", "notDone", element.getNotDoneElement(), -1); 8217 if (element.hasNotDoneReason()) 8218 composeType(t, "MedicationDispense", "notDoneReason", element.getNotDoneReason(), -1); 8219 for (int i = 0; i < element.getEventHistory().size(); i++) 8220 composeReference(t, "MedicationDispense", "eventHistory", element.getEventHistory().get(i), i); 8221 } 8222 8223 protected void composeMedicationDispenseMedicationDispensePerformerComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispensePerformerComponent element, int index) { 8224 if (element == null) 8225 return; 8226 Complex t; 8227 if (Utilities.noString(parentType)) 8228 t = parent; 8229 else { 8230 t = parent.predicate("fhir:"+parentType+'.'+name); 8231 } 8232 composeBackboneElement(t, "performer", name, element, index); 8233 if (element.hasActor()) 8234 composeReference(t, "MedicationDispense", "actor", element.getActor(), -1); 8235 if (element.hasOnBehalfOf()) 8236 composeReference(t, "MedicationDispense", "onBehalfOf", element.getOnBehalfOf(), -1); 8237 } 8238 8239 protected void composeMedicationDispenseMedicationDispenseSubstitutionComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispenseSubstitutionComponent element, int index) { 8240 if (element == null) 8241 return; 8242 Complex t; 8243 if (Utilities.noString(parentType)) 8244 t = parent; 8245 else { 8246 t = parent.predicate("fhir:"+parentType+'.'+name); 8247 } 8248 composeBackboneElement(t, "substitution", name, element, index); 8249 if (element.hasWasSubstitutedElement()) 8250 composeBoolean(t, "MedicationDispense", "wasSubstituted", element.getWasSubstitutedElement(), -1); 8251 if (element.hasType()) 8252 composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1); 8253 for (int i = 0; i < element.getReason().size(); i++) 8254 composeCodeableConcept(t, "MedicationDispense", "reason", element.getReason().get(i), i); 8255 for (int i = 0; i < element.getResponsibleParty().size(); i++) 8256 composeReference(t, "MedicationDispense", "responsibleParty", element.getResponsibleParty().get(i), i); 8257 } 8258 8259 protected void composeMedicationRequest(Complex parent, String parentType, String name, MedicationRequest 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 composeDomainResource(t, "MedicationRequest", name, element, index); 8269 for (int i = 0; i < element.getIdentifier().size(); i++) 8270 composeIdentifier(t, "MedicationRequest", "identifier", element.getIdentifier().get(i), i); 8271 for (int i = 0; i < element.getDefinition().size(); i++) 8272 composeReference(t, "MedicationRequest", "definition", element.getDefinition().get(i), i); 8273 for (int i = 0; i < element.getBasedOn().size(); i++) 8274 composeReference(t, "MedicationRequest", "basedOn", element.getBasedOn().get(i), i); 8275 if (element.hasGroupIdentifier()) 8276 composeIdentifier(t, "MedicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 8277 if (element.hasStatusElement()) 8278 composeEnum(t, "MedicationRequest", "status", element.getStatusElement(), -1); 8279 if (element.hasIntentElement()) 8280 composeEnum(t, "MedicationRequest", "intent", element.getIntentElement(), -1); 8281 if (element.hasCategory()) 8282 composeCodeableConcept(t, "MedicationRequest", "category", element.getCategory(), -1); 8283 if (element.hasPriorityElement()) 8284 composeEnum(t, "MedicationRequest", "priority", element.getPriorityElement(), -1); 8285 if (element.hasMedication()) 8286 composeType(t, "MedicationRequest", "medication", element.getMedication(), -1); 8287 if (element.hasSubject()) 8288 composeReference(t, "MedicationRequest", "subject", element.getSubject(), -1); 8289 if (element.hasContext()) 8290 composeReference(t, "MedicationRequest", "context", element.getContext(), -1); 8291 for (int i = 0; i < element.getSupportingInformation().size(); i++) 8292 composeReference(t, "MedicationRequest", "supportingInformation", element.getSupportingInformation().get(i), i); 8293 if (element.hasAuthoredOnElement()) 8294 composeDateTime(t, "MedicationRequest", "authoredOn", element.getAuthoredOnElement(), -1); 8295 if (element.hasRequester()) 8296 composeMedicationRequestMedicationRequestRequesterComponent(t, "MedicationRequest", "requester", element.getRequester(), -1); 8297 if (element.hasRecorder()) 8298 composeReference(t, "MedicationRequest", "recorder", element.getRecorder(), -1); 8299 for (int i = 0; i < element.getReasonCode().size(); i++) 8300 composeCodeableConcept(t, "MedicationRequest", "reasonCode", element.getReasonCode().get(i), i); 8301 for (int i = 0; i < element.getReasonReference().size(); i++) 8302 composeReference(t, "MedicationRequest", "reasonReference", element.getReasonReference().get(i), i); 8303 for (int i = 0; i < element.getNote().size(); i++) 8304 composeAnnotation(t, "MedicationRequest", "note", element.getNote().get(i), i); 8305 for (int i = 0; i < element.getDosageInstruction().size(); i++) 8306 composeDosage(t, "MedicationRequest", "dosageInstruction", element.getDosageInstruction().get(i), i); 8307 if (element.hasDispenseRequest()) 8308 composeMedicationRequestMedicationRequestDispenseRequestComponent(t, "MedicationRequest", "dispenseRequest", element.getDispenseRequest(), -1); 8309 if (element.hasSubstitution()) 8310 composeMedicationRequestMedicationRequestSubstitutionComponent(t, "MedicationRequest", "substitution", element.getSubstitution(), -1); 8311 if (element.hasPriorPrescription()) 8312 composeReference(t, "MedicationRequest", "priorPrescription", element.getPriorPrescription(), -1); 8313 for (int i = 0; i < element.getDetectedIssue().size(); i++) 8314 composeReference(t, "MedicationRequest", "detectedIssue", element.getDetectedIssue().get(i), i); 8315 for (int i = 0; i < element.getEventHistory().size(); i++) 8316 composeReference(t, "MedicationRequest", "eventHistory", element.getEventHistory().get(i), i); 8317 } 8318 8319 protected void composeMedicationRequestMedicationRequestRequesterComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestRequesterComponent element, int index) { 8320 if (element == null) 8321 return; 8322 Complex t; 8323 if (Utilities.noString(parentType)) 8324 t = parent; 8325 else { 8326 t = parent.predicate("fhir:"+parentType+'.'+name); 8327 } 8328 composeBackboneElement(t, "requester", name, element, index); 8329 if (element.hasAgent()) 8330 composeReference(t, "MedicationRequest", "agent", element.getAgent(), -1); 8331 if (element.hasOnBehalfOf()) 8332 composeReference(t, "MedicationRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 8333 } 8334 8335 protected void composeMedicationRequestMedicationRequestDispenseRequestComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestDispenseRequestComponent element, int index) { 8336 if (element == null) 8337 return; 8338 Complex t; 8339 if (Utilities.noString(parentType)) 8340 t = parent; 8341 else { 8342 t = parent.predicate("fhir:"+parentType+'.'+name); 8343 } 8344 composeBackboneElement(t, "dispenseRequest", name, element, index); 8345 if (element.hasValidityPeriod()) 8346 composePeriod(t, "MedicationRequest", "validityPeriod", element.getValidityPeriod(), -1); 8347 if (element.hasNumberOfRepeatsAllowedElement()) 8348 composePositiveInt(t, "MedicationRequest", "numberOfRepeatsAllowed", element.getNumberOfRepeatsAllowedElement(), -1); 8349 if (element.hasQuantity()) 8350 composeQuantity(t, "MedicationRequest", "quantity", element.getQuantity(), -1); 8351 if (element.hasExpectedSupplyDuration()) 8352 composeDuration(t, "MedicationRequest", "expectedSupplyDuration", element.getExpectedSupplyDuration(), -1); 8353 if (element.hasPerformer()) 8354 composeReference(t, "MedicationRequest", "performer", element.getPerformer(), -1); 8355 } 8356 8357 protected void composeMedicationRequestMedicationRequestSubstitutionComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestSubstitutionComponent element, int index) { 8358 if (element == null) 8359 return; 8360 Complex t; 8361 if (Utilities.noString(parentType)) 8362 t = parent; 8363 else { 8364 t = parent.predicate("fhir:"+parentType+'.'+name); 8365 } 8366 composeBackboneElement(t, "substitution", name, element, index); 8367 if (element.hasAllowedElement()) 8368 composeBoolean(t, "MedicationRequest", "allowed", element.getAllowedElement(), -1); 8369 if (element.hasReason()) 8370 composeCodeableConcept(t, "MedicationRequest", "reason", element.getReason(), -1); 8371 } 8372 8373 protected void composeMedicationStatement(Complex parent, String parentType, String name, MedicationStatement element, int index) { 8374 if (element == null) 8375 return; 8376 Complex t; 8377 if (Utilities.noString(parentType)) 8378 t = parent; 8379 else { 8380 t = parent.predicate("fhir:"+parentType+'.'+name); 8381 } 8382 composeDomainResource(t, "MedicationStatement", name, element, index); 8383 for (int i = 0; i < element.getIdentifier().size(); i++) 8384 composeIdentifier(t, "MedicationStatement", "identifier", element.getIdentifier().get(i), i); 8385 for (int i = 0; i < element.getBasedOn().size(); i++) 8386 composeReference(t, "MedicationStatement", "basedOn", element.getBasedOn().get(i), i); 8387 for (int i = 0; i < element.getPartOf().size(); i++) 8388 composeReference(t, "MedicationStatement", "partOf", element.getPartOf().get(i), i); 8389 if (element.hasContext()) 8390 composeReference(t, "MedicationStatement", "context", element.getContext(), -1); 8391 if (element.hasStatusElement()) 8392 composeEnum(t, "MedicationStatement", "status", element.getStatusElement(), -1); 8393 if (element.hasCategory()) 8394 composeCodeableConcept(t, "MedicationStatement", "category", element.getCategory(), -1); 8395 if (element.hasMedication()) 8396 composeType(t, "MedicationStatement", "medication", element.getMedication(), -1); 8397 if (element.hasEffective()) 8398 composeType(t, "MedicationStatement", "effective", element.getEffective(), -1); 8399 if (element.hasDateAssertedElement()) 8400 composeDateTime(t, "MedicationStatement", "dateAsserted", element.getDateAssertedElement(), -1); 8401 if (element.hasInformationSource()) 8402 composeReference(t, "MedicationStatement", "informationSource", element.getInformationSource(), -1); 8403 if (element.hasSubject()) 8404 composeReference(t, "MedicationStatement", "subject", element.getSubject(), -1); 8405 for (int i = 0; i < element.getDerivedFrom().size(); i++) 8406 composeReference(t, "MedicationStatement", "derivedFrom", element.getDerivedFrom().get(i), i); 8407 if (element.hasTakenElement()) 8408 composeEnum(t, "MedicationStatement", "taken", element.getTakenElement(), -1); 8409 for (int i = 0; i < element.getReasonNotTaken().size(); i++) 8410 composeCodeableConcept(t, "MedicationStatement", "reasonNotTaken", element.getReasonNotTaken().get(i), i); 8411 for (int i = 0; i < element.getReasonCode().size(); i++) 8412 composeCodeableConcept(t, "MedicationStatement", "reasonCode", element.getReasonCode().get(i), i); 8413 for (int i = 0; i < element.getReasonReference().size(); i++) 8414 composeReference(t, "MedicationStatement", "reasonReference", element.getReasonReference().get(i), i); 8415 for (int i = 0; i < element.getNote().size(); i++) 8416 composeAnnotation(t, "MedicationStatement", "note", element.getNote().get(i), i); 8417 for (int i = 0; i < element.getDosage().size(); i++) 8418 composeDosage(t, "MedicationStatement", "dosage", element.getDosage().get(i), i); 8419 } 8420 8421 protected void composeMessageDefinition(Complex parent, String parentType, String name, MessageDefinition element, int index) { 8422 if (element == null) 8423 return; 8424 Complex t; 8425 if (Utilities.noString(parentType)) 8426 t = parent; 8427 else { 8428 t = parent.predicate("fhir:"+parentType+'.'+name); 8429 } 8430 composeDomainResource(t, "MessageDefinition", name, element, index); 8431 if (element.hasUrlElement()) 8432 composeUri(t, "MessageDefinition", "url", element.getUrlElement(), -1); 8433 if (element.hasIdentifier()) 8434 composeIdentifier(t, "MessageDefinition", "identifier", element.getIdentifier(), -1); 8435 if (element.hasVersionElement()) 8436 composeString(t, "MessageDefinition", "version", element.getVersionElement(), -1); 8437 if (element.hasNameElement()) 8438 composeString(t, "MessageDefinition", "name", element.getNameElement(), -1); 8439 if (element.hasTitleElement()) 8440 composeString(t, "MessageDefinition", "title", element.getTitleElement(), -1); 8441 if (element.hasStatusElement()) 8442 composeEnum(t, "MessageDefinition", "status", element.getStatusElement(), -1); 8443 if (element.hasExperimentalElement()) 8444 composeBoolean(t, "MessageDefinition", "experimental", element.getExperimentalElement(), -1); 8445 if (element.hasDateElement()) 8446 composeDateTime(t, "MessageDefinition", "date", element.getDateElement(), -1); 8447 if (element.hasPublisherElement()) 8448 composeString(t, "MessageDefinition", "publisher", element.getPublisherElement(), -1); 8449 for (int i = 0; i < element.getContact().size(); i++) 8450 composeContactDetail(t, "MessageDefinition", "contact", element.getContact().get(i), i); 8451 if (element.hasDescriptionElement()) 8452 composeMarkdown(t, "MessageDefinition", "description", element.getDescriptionElement(), -1); 8453 for (int i = 0; i < element.getUseContext().size(); i++) 8454 composeUsageContext(t, "MessageDefinition", "useContext", element.getUseContext().get(i), i); 8455 for (int i = 0; i < element.getJurisdiction().size(); i++) 8456 composeCodeableConcept(t, "MessageDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 8457 if (element.hasPurposeElement()) 8458 composeMarkdown(t, "MessageDefinition", "purpose", element.getPurposeElement(), -1); 8459 if (element.hasCopyrightElement()) 8460 composeMarkdown(t, "MessageDefinition", "copyright", element.getCopyrightElement(), -1); 8461 if (element.hasBase()) 8462 composeReference(t, "MessageDefinition", "base", element.getBase(), -1); 8463 for (int i = 0; i < element.getParent().size(); i++) 8464 composeReference(t, "MessageDefinition", "parent", element.getParent().get(i), i); 8465 for (int i = 0; i < element.getReplaces().size(); i++) 8466 composeReference(t, "MessageDefinition", "replaces", element.getReplaces().get(i), i); 8467 if (element.hasEvent()) 8468 composeCoding(t, "MessageDefinition", "event", element.getEvent(), -1); 8469 if (element.hasCategoryElement()) 8470 composeEnum(t, "MessageDefinition", "category", element.getCategoryElement(), -1); 8471 for (int i = 0; i < element.getFocus().size(); i++) 8472 composeMessageDefinitionMessageDefinitionFocusComponent(t, "MessageDefinition", "focus", element.getFocus().get(i), i); 8473 if (element.hasResponseRequiredElement()) 8474 composeBoolean(t, "MessageDefinition", "responseRequired", element.getResponseRequiredElement(), -1); 8475 for (int i = 0; i < element.getAllowedResponse().size(); i++) 8476 composeMessageDefinitionMessageDefinitionAllowedResponseComponent(t, "MessageDefinition", "allowedResponse", element.getAllowedResponse().get(i), i); 8477 } 8478 8479 protected void composeMessageDefinitionMessageDefinitionFocusComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionFocusComponent element, int index) { 8480 if (element == null) 8481 return; 8482 Complex t; 8483 if (Utilities.noString(parentType)) 8484 t = parent; 8485 else { 8486 t = parent.predicate("fhir:"+parentType+'.'+name); 8487 } 8488 composeBackboneElement(t, "focus", name, element, index); 8489 if (element.hasCodeElement()) 8490 composeCode(t, "MessageDefinition", "code", element.getCodeElement(), -1); 8491 if (element.hasProfile()) 8492 composeReference(t, "MessageDefinition", "profile", element.getProfile(), -1); 8493 if (element.hasMinElement()) 8494 composeUnsignedInt(t, "MessageDefinition", "min", element.getMinElement(), -1); 8495 if (element.hasMaxElement()) 8496 composeString(t, "MessageDefinition", "max", element.getMaxElement(), -1); 8497 } 8498 8499 protected void composeMessageDefinitionMessageDefinitionAllowedResponseComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionAllowedResponseComponent 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, "allowedResponse", name, element, index); 8509 if (element.hasMessage()) 8510 composeReference(t, "MessageDefinition", "message", element.getMessage(), -1); 8511 if (element.hasSituationElement()) 8512 composeMarkdown(t, "MessageDefinition", "situation", element.getSituationElement(), -1); 8513 } 8514 8515 protected void composeMessageHeader(Complex parent, String parentType, String name, MessageHeader element, int index) { 8516 if (element == null) 8517 return; 8518 Complex t; 8519 if (Utilities.noString(parentType)) 8520 t = parent; 8521 else { 8522 t = parent.predicate("fhir:"+parentType+'.'+name); 8523 } 8524 composeDomainResource(t, "MessageHeader", name, element, index); 8525 if (element.hasEvent()) 8526 composeCoding(t, "MessageHeader", "event", element.getEvent(), -1); 8527 for (int i = 0; i < element.getDestination().size(); i++) 8528 composeMessageHeaderMessageDestinationComponent(t, "MessageHeader", "destination", element.getDestination().get(i), i); 8529 if (element.hasReceiver()) 8530 composeReference(t, "MessageHeader", "receiver", element.getReceiver(), -1); 8531 if (element.hasSender()) 8532 composeReference(t, "MessageHeader", "sender", element.getSender(), -1); 8533 if (element.hasTimestampElement()) 8534 composeInstant(t, "MessageHeader", "timestamp", element.getTimestampElement(), -1); 8535 if (element.hasEnterer()) 8536 composeReference(t, "MessageHeader", "enterer", element.getEnterer(), -1); 8537 if (element.hasAuthor()) 8538 composeReference(t, "MessageHeader", "author", element.getAuthor(), -1); 8539 if (element.hasSource()) 8540 composeMessageHeaderMessageSourceComponent(t, "MessageHeader", "source", element.getSource(), -1); 8541 if (element.hasResponsible()) 8542 composeReference(t, "MessageHeader", "responsible", element.getResponsible(), -1); 8543 if (element.hasReason()) 8544 composeCodeableConcept(t, "MessageHeader", "reason", element.getReason(), -1); 8545 if (element.hasResponse()) 8546 composeMessageHeaderMessageHeaderResponseComponent(t, "MessageHeader", "response", element.getResponse(), -1); 8547 for (int i = 0; i < element.getFocus().size(); i++) 8548 composeReference(t, "MessageHeader", "focus", element.getFocus().get(i), i); 8549 } 8550 8551 protected void composeMessageHeaderMessageDestinationComponent(Complex parent, String parentType, String name, MessageHeader.MessageDestinationComponent element, int index) { 8552 if (element == null) 8553 return; 8554 Complex t; 8555 if (Utilities.noString(parentType)) 8556 t = parent; 8557 else { 8558 t = parent.predicate("fhir:"+parentType+'.'+name); 8559 } 8560 composeBackboneElement(t, "destination", name, element, index); 8561 if (element.hasNameElement()) 8562 composeString(t, "MessageHeader", "name", element.getNameElement(), -1); 8563 if (element.hasTarget()) 8564 composeReference(t, "MessageHeader", "target", element.getTarget(), -1); 8565 if (element.hasEndpointElement()) 8566 composeUri(t, "MessageHeader", "endpoint", element.getEndpointElement(), -1); 8567 } 8568 8569 protected void composeMessageHeaderMessageSourceComponent(Complex parent, String parentType, String name, MessageHeader.MessageSourceComponent element, int index) { 8570 if (element == null) 8571 return; 8572 Complex t; 8573 if (Utilities.noString(parentType)) 8574 t = parent; 8575 else { 8576 t = parent.predicate("fhir:"+parentType+'.'+name); 8577 } 8578 composeBackboneElement(t, "source", name, element, index); 8579 if (element.hasNameElement()) 8580 composeString(t, "MessageHeader", "name", element.getNameElement(), -1); 8581 if (element.hasSoftwareElement()) 8582 composeString(t, "MessageHeader", "software", element.getSoftwareElement(), -1); 8583 if (element.hasVersionElement()) 8584 composeString(t, "MessageHeader", "version", element.getVersionElement(), -1); 8585 if (element.hasContact()) 8586 composeContactPoint(t, "MessageHeader", "contact", element.getContact(), -1); 8587 if (element.hasEndpointElement()) 8588 composeUri(t, "MessageHeader", "endpoint", element.getEndpointElement(), -1); 8589 } 8590 8591 protected void composeMessageHeaderMessageHeaderResponseComponent(Complex parent, String parentType, String name, MessageHeader.MessageHeaderResponseComponent element, int index) { 8592 if (element == null) 8593 return; 8594 Complex t; 8595 if (Utilities.noString(parentType)) 8596 t = parent; 8597 else { 8598 t = parent.predicate("fhir:"+parentType+'.'+name); 8599 } 8600 composeBackboneElement(t, "response", name, element, index); 8601 if (element.hasIdentifierElement()) 8602 composeId(t, "MessageHeader", "identifier", element.getIdentifierElement(), -1); 8603 if (element.hasCodeElement()) 8604 composeEnum(t, "MessageHeader", "code", element.getCodeElement(), -1); 8605 if (element.hasDetails()) 8606 composeReference(t, "MessageHeader", "details", element.getDetails(), -1); 8607 } 8608 8609 protected void composeNamingSystem(Complex parent, String parentType, String name, NamingSystem element, int index) { 8610 if (element == null) 8611 return; 8612 Complex t; 8613 if (Utilities.noString(parentType)) 8614 t = parent; 8615 else { 8616 t = parent.predicate("fhir:"+parentType+'.'+name); 8617 } 8618 composeDomainResource(t, "NamingSystem", name, element, index); 8619 if (element.hasNameElement()) 8620 composeString(t, "NamingSystem", "name", element.getNameElement(), -1); 8621 if (element.hasStatusElement()) 8622 composeEnum(t, "NamingSystem", "status", element.getStatusElement(), -1); 8623 if (element.hasKindElement()) 8624 composeEnum(t, "NamingSystem", "kind", element.getKindElement(), -1); 8625 if (element.hasDateElement()) 8626 composeDateTime(t, "NamingSystem", "date", element.getDateElement(), -1); 8627 if (element.hasPublisherElement()) 8628 composeString(t, "NamingSystem", "publisher", element.getPublisherElement(), -1); 8629 for (int i = 0; i < element.getContact().size(); i++) 8630 composeContactDetail(t, "NamingSystem", "contact", element.getContact().get(i), i); 8631 if (element.hasResponsibleElement()) 8632 composeString(t, "NamingSystem", "responsible", element.getResponsibleElement(), -1); 8633 if (element.hasType()) 8634 composeCodeableConcept(t, "NamingSystem", "type", element.getType(), -1); 8635 if (element.hasDescriptionElement()) 8636 composeMarkdown(t, "NamingSystem", "description", element.getDescriptionElement(), -1); 8637 for (int i = 0; i < element.getUseContext().size(); i++) 8638 composeUsageContext(t, "NamingSystem", "useContext", element.getUseContext().get(i), i); 8639 for (int i = 0; i < element.getJurisdiction().size(); i++) 8640 composeCodeableConcept(t, "NamingSystem", "jurisdiction", element.getJurisdiction().get(i), i); 8641 if (element.hasUsageElement()) 8642 composeString(t, "NamingSystem", "usage", element.getUsageElement(), -1); 8643 for (int i = 0; i < element.getUniqueId().size(); i++) 8644 composeNamingSystemNamingSystemUniqueIdComponent(t, "NamingSystem", "uniqueId", element.getUniqueId().get(i), i); 8645 if (element.hasReplacedBy()) 8646 composeReference(t, "NamingSystem", "replacedBy", element.getReplacedBy(), -1); 8647 } 8648 8649 protected void composeNamingSystemNamingSystemUniqueIdComponent(Complex parent, String parentType, String name, NamingSystem.NamingSystemUniqueIdComponent element, int index) { 8650 if (element == null) 8651 return; 8652 Complex t; 8653 if (Utilities.noString(parentType)) 8654 t = parent; 8655 else { 8656 t = parent.predicate("fhir:"+parentType+'.'+name); 8657 } 8658 composeBackboneElement(t, "uniqueId", name, element, index); 8659 if (element.hasTypeElement()) 8660 composeEnum(t, "NamingSystem", "type", element.getTypeElement(), -1); 8661 if (element.hasValueElement()) 8662 composeString(t, "NamingSystem", "value", element.getValueElement(), -1); 8663 if (element.hasPreferredElement()) 8664 composeBoolean(t, "NamingSystem", "preferred", element.getPreferredElement(), -1); 8665 if (element.hasCommentElement()) 8666 composeString(t, "NamingSystem", "comment", element.getCommentElement(), -1); 8667 if (element.hasPeriod()) 8668 composePeriod(t, "NamingSystem", "period", element.getPeriod(), -1); 8669 } 8670 8671 protected void composeNutritionOrder(Complex parent, String parentType, String name, NutritionOrder element, int index) { 8672 if (element == null) 8673 return; 8674 Complex t; 8675 if (Utilities.noString(parentType)) 8676 t = parent; 8677 else { 8678 t = parent.predicate("fhir:"+parentType+'.'+name); 8679 } 8680 composeDomainResource(t, "NutritionOrder", name, element, index); 8681 for (int i = 0; i < element.getIdentifier().size(); i++) 8682 composeIdentifier(t, "NutritionOrder", "identifier", element.getIdentifier().get(i), i); 8683 if (element.hasStatusElement()) 8684 composeEnum(t, "NutritionOrder", "status", element.getStatusElement(), -1); 8685 if (element.hasPatient()) 8686 composeReference(t, "NutritionOrder", "patient", element.getPatient(), -1); 8687 if (element.hasEncounter()) 8688 composeReference(t, "NutritionOrder", "encounter", element.getEncounter(), -1); 8689 if (element.hasDateTimeElement()) 8690 composeDateTime(t, "NutritionOrder", "dateTime", element.getDateTimeElement(), -1); 8691 if (element.hasOrderer()) 8692 composeReference(t, "NutritionOrder", "orderer", element.getOrderer(), -1); 8693 for (int i = 0; i < element.getAllergyIntolerance().size(); i++) 8694 composeReference(t, "NutritionOrder", "allergyIntolerance", element.getAllergyIntolerance().get(i), i); 8695 for (int i = 0; i < element.getFoodPreferenceModifier().size(); i++) 8696 composeCodeableConcept(t, "NutritionOrder", "foodPreferenceModifier", element.getFoodPreferenceModifier().get(i), i); 8697 for (int i = 0; i < element.getExcludeFoodModifier().size(); i++) 8698 composeCodeableConcept(t, "NutritionOrder", "excludeFoodModifier", element.getExcludeFoodModifier().get(i), i); 8699 if (element.hasOralDiet()) 8700 composeNutritionOrderNutritionOrderOralDietComponent(t, "NutritionOrder", "oralDiet", element.getOralDiet(), -1); 8701 for (int i = 0; i < element.getSupplement().size(); i++) 8702 composeNutritionOrderNutritionOrderSupplementComponent(t, "NutritionOrder", "supplement", element.getSupplement().get(i), i); 8703 if (element.hasEnteralFormula()) 8704 composeNutritionOrderNutritionOrderEnteralFormulaComponent(t, "NutritionOrder", "enteralFormula", element.getEnteralFormula(), -1); 8705 } 8706 8707 protected void composeNutritionOrderNutritionOrderOralDietComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietComponent element, int index) { 8708 if (element == null) 8709 return; 8710 Complex t; 8711 if (Utilities.noString(parentType)) 8712 t = parent; 8713 else { 8714 t = parent.predicate("fhir:"+parentType+'.'+name); 8715 } 8716 composeBackboneElement(t, "oralDiet", name, element, index); 8717 for (int i = 0; i < element.getType().size(); i++) 8718 composeCodeableConcept(t, "NutritionOrder", "type", element.getType().get(i), i); 8719 for (int i = 0; i < element.getSchedule().size(); i++) 8720 composeTiming(t, "NutritionOrder", "schedule", element.getSchedule().get(i), i); 8721 for (int i = 0; i < element.getNutrient().size(); i++) 8722 composeNutritionOrderNutritionOrderOralDietNutrientComponent(t, "NutritionOrder", "nutrient", element.getNutrient().get(i), i); 8723 for (int i = 0; i < element.getTexture().size(); i++) 8724 composeNutritionOrderNutritionOrderOralDietTextureComponent(t, "NutritionOrder", "texture", element.getTexture().get(i), i); 8725 for (int i = 0; i < element.getFluidConsistencyType().size(); i++) 8726 composeCodeableConcept(t, "NutritionOrder", "fluidConsistencyType", element.getFluidConsistencyType().get(i), i); 8727 if (element.hasInstructionElement()) 8728 composeString(t, "NutritionOrder", "instruction", element.getInstructionElement(), -1); 8729 } 8730 8731 protected void composeNutritionOrderNutritionOrderOralDietNutrientComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietNutrientComponent element, int index) { 8732 if (element == null) 8733 return; 8734 Complex t; 8735 if (Utilities.noString(parentType)) 8736 t = parent; 8737 else { 8738 t = parent.predicate("fhir:"+parentType+'.'+name); 8739 } 8740 composeBackboneElement(t, "nutrient", name, element, index); 8741 if (element.hasModifier()) 8742 composeCodeableConcept(t, "NutritionOrder", "modifier", element.getModifier(), -1); 8743 if (element.hasAmount()) 8744 composeQuantity(t, "NutritionOrder", "amount", element.getAmount(), -1); 8745 } 8746 8747 protected void composeNutritionOrderNutritionOrderOralDietTextureComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietTextureComponent element, int index) { 8748 if (element == null) 8749 return; 8750 Complex t; 8751 if (Utilities.noString(parentType)) 8752 t = parent; 8753 else { 8754 t = parent.predicate("fhir:"+parentType+'.'+name); 8755 } 8756 composeBackboneElement(t, "texture", name, element, index); 8757 if (element.hasModifier()) 8758 composeCodeableConcept(t, "NutritionOrder", "modifier", element.getModifier(), -1); 8759 if (element.hasFoodType()) 8760 composeCodeableConcept(t, "NutritionOrder", "foodType", element.getFoodType(), -1); 8761 } 8762 8763 protected void composeNutritionOrderNutritionOrderSupplementComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderSupplementComponent element, int index) { 8764 if (element == null) 8765 return; 8766 Complex t; 8767 if (Utilities.noString(parentType)) 8768 t = parent; 8769 else { 8770 t = parent.predicate("fhir:"+parentType+'.'+name); 8771 } 8772 composeBackboneElement(t, "supplement", name, element, index); 8773 if (element.hasType()) 8774 composeCodeableConcept(t, "NutritionOrder", "type", element.getType(), -1); 8775 if (element.hasProductNameElement()) 8776 composeString(t, "NutritionOrder", "productName", element.getProductNameElement(), -1); 8777 for (int i = 0; i < element.getSchedule().size(); i++) 8778 composeTiming(t, "NutritionOrder", "schedule", element.getSchedule().get(i), i); 8779 if (element.hasQuantity()) 8780 composeQuantity(t, "NutritionOrder", "quantity", element.getQuantity(), -1); 8781 if (element.hasInstructionElement()) 8782 composeString(t, "NutritionOrder", "instruction", element.getInstructionElement(), -1); 8783 } 8784 8785 protected void composeNutritionOrderNutritionOrderEnteralFormulaComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaComponent element, int index) { 8786 if (element == null) 8787 return; 8788 Complex t; 8789 if (Utilities.noString(parentType)) 8790 t = parent; 8791 else { 8792 t = parent.predicate("fhir:"+parentType+'.'+name); 8793 } 8794 composeBackboneElement(t, "enteralFormula", name, element, index); 8795 if (element.hasBaseFormulaType()) 8796 composeCodeableConcept(t, "NutritionOrder", "baseFormulaType", element.getBaseFormulaType(), -1); 8797 if (element.hasBaseFormulaProductNameElement()) 8798 composeString(t, "NutritionOrder", "baseFormulaProductName", element.getBaseFormulaProductNameElement(), -1); 8799 if (element.hasAdditiveType()) 8800 composeCodeableConcept(t, "NutritionOrder", "additiveType", element.getAdditiveType(), -1); 8801 if (element.hasAdditiveProductNameElement()) 8802 composeString(t, "NutritionOrder", "additiveProductName", element.getAdditiveProductNameElement(), -1); 8803 if (element.hasCaloricDensity()) 8804 composeQuantity(t, "NutritionOrder", "caloricDensity", element.getCaloricDensity(), -1); 8805 if (element.hasRouteofAdministration()) 8806 composeCodeableConcept(t, "NutritionOrder", "routeofAdministration", element.getRouteofAdministration(), -1); 8807 for (int i = 0; i < element.getAdministration().size(); i++) 8808 composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(t, "NutritionOrder", "administration", element.getAdministration().get(i), i); 8809 if (element.hasMaxVolumeToDeliver()) 8810 composeQuantity(t, "NutritionOrder", "maxVolumeToDeliver", element.getMaxVolumeToDeliver(), -1); 8811 if (element.hasAdministrationInstructionElement()) 8812 composeString(t, "NutritionOrder", "administrationInstruction", element.getAdministrationInstructionElement(), -1); 8813 } 8814 8815 protected void composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent element, int index) { 8816 if (element == null) 8817 return; 8818 Complex t; 8819 if (Utilities.noString(parentType)) 8820 t = parent; 8821 else { 8822 t = parent.predicate("fhir:"+parentType+'.'+name); 8823 } 8824 composeBackboneElement(t, "administration", name, element, index); 8825 if (element.hasSchedule()) 8826 composeTiming(t, "NutritionOrder", "schedule", element.getSchedule(), -1); 8827 if (element.hasQuantity()) 8828 composeQuantity(t, "NutritionOrder", "quantity", element.getQuantity(), -1); 8829 if (element.hasRate()) 8830 composeType(t, "NutritionOrder", "rate", element.getRate(), -1); 8831 } 8832 8833 protected void composeObservation(Complex parent, String parentType, String name, Observation element, int index) { 8834 if (element == null) 8835 return; 8836 Complex t; 8837 if (Utilities.noString(parentType)) 8838 t = parent; 8839 else { 8840 t = parent.predicate("fhir:"+parentType+'.'+name); 8841 } 8842 composeDomainResource(t, "Observation", name, element, index); 8843 for (int i = 0; i < element.getIdentifier().size(); i++) 8844 composeIdentifier(t, "Observation", "identifier", element.getIdentifier().get(i), i); 8845 for (int i = 0; i < element.getBasedOn().size(); i++) 8846 composeReference(t, "Observation", "basedOn", element.getBasedOn().get(i), i); 8847 if (element.hasStatusElement()) 8848 composeEnum(t, "Observation", "status", element.getStatusElement(), -1); 8849 for (int i = 0; i < element.getCategory().size(); i++) 8850 composeCodeableConcept(t, "Observation", "category", element.getCategory().get(i), i); 8851 if (element.hasCode()) 8852 composeCodeableConcept(t, "Observation", "code", element.getCode(), -1); 8853 if (element.hasSubject()) 8854 composeReference(t, "Observation", "subject", element.getSubject(), -1); 8855 if (element.hasContext()) 8856 composeReference(t, "Observation", "context", element.getContext(), -1); 8857 if (element.hasEffective()) 8858 composeType(t, "Observation", "effective", element.getEffective(), -1); 8859 if (element.hasIssuedElement()) 8860 composeInstant(t, "Observation", "issued", element.getIssuedElement(), -1); 8861 for (int i = 0; i < element.getPerformer().size(); i++) 8862 composeReference(t, "Observation", "performer", element.getPerformer().get(i), i); 8863 if (element.hasValue()) 8864 composeType(t, "Observation", "value", element.getValue(), -1); 8865 if (element.hasDataAbsentReason()) 8866 composeCodeableConcept(t, "Observation", "dataAbsentReason", element.getDataAbsentReason(), -1); 8867 if (element.hasInterpretation()) 8868 composeCodeableConcept(t, "Observation", "interpretation", element.getInterpretation(), -1); 8869 if (element.hasCommentElement()) 8870 composeString(t, "Observation", "comment", element.getCommentElement(), -1); 8871 if (element.hasBodySite()) 8872 composeCodeableConcept(t, "Observation", "bodySite", element.getBodySite(), -1); 8873 if (element.hasMethod()) 8874 composeCodeableConcept(t, "Observation", "method", element.getMethod(), -1); 8875 if (element.hasSpecimen()) 8876 composeReference(t, "Observation", "specimen", element.getSpecimen(), -1); 8877 if (element.hasDevice()) 8878 composeReference(t, "Observation", "device", element.getDevice(), -1); 8879 for (int i = 0; i < element.getReferenceRange().size(); i++) 8880 composeObservationObservationReferenceRangeComponent(t, "Observation", "referenceRange", element.getReferenceRange().get(i), i); 8881 for (int i = 0; i < element.getRelated().size(); i++) 8882 composeObservationObservationRelatedComponent(t, "Observation", "related", element.getRelated().get(i), i); 8883 for (int i = 0; i < element.getComponent().size(); i++) 8884 composeObservationObservationComponentComponent(t, "Observation", "component", element.getComponent().get(i), i); 8885 } 8886 8887 protected void composeObservationObservationReferenceRangeComponent(Complex parent, String parentType, String name, Observation.ObservationReferenceRangeComponent element, int index) { 8888 if (element == null) 8889 return; 8890 Complex t; 8891 if (Utilities.noString(parentType)) 8892 t = parent; 8893 else { 8894 t = parent.predicate("fhir:"+parentType+'.'+name); 8895 } 8896 composeBackboneElement(t, "referenceRange", name, element, index); 8897 if (element.hasLow()) 8898 composeQuantity(t, "Observation", "low", element.getLow(), -1); 8899 if (element.hasHigh()) 8900 composeQuantity(t, "Observation", "high", element.getHigh(), -1); 8901 if (element.hasType()) 8902 composeCodeableConcept(t, "Observation", "type", element.getType(), -1); 8903 for (int i = 0; i < element.getAppliesTo().size(); i++) 8904 composeCodeableConcept(t, "Observation", "appliesTo", element.getAppliesTo().get(i), i); 8905 if (element.hasAge()) 8906 composeRange(t, "Observation", "age", element.getAge(), -1); 8907 if (element.hasTextElement()) 8908 composeString(t, "Observation", "text", element.getTextElement(), -1); 8909 } 8910 8911 protected void composeObservationObservationRelatedComponent(Complex parent, String parentType, String name, Observation.ObservationRelatedComponent element, int index) { 8912 if (element == null) 8913 return; 8914 Complex t; 8915 if (Utilities.noString(parentType)) 8916 t = parent; 8917 else { 8918 t = parent.predicate("fhir:"+parentType+'.'+name); 8919 } 8920 composeBackboneElement(t, "related", name, element, index); 8921 if (element.hasTypeElement()) 8922 composeEnum(t, "Observation", "type", element.getTypeElement(), -1); 8923 if (element.hasTarget()) 8924 composeReference(t, "Observation", "target", element.getTarget(), -1); 8925 } 8926 8927 protected void composeObservationObservationComponentComponent(Complex parent, String parentType, String name, Observation.ObservationComponentComponent element, int index) { 8928 if (element == null) 8929 return; 8930 Complex t; 8931 if (Utilities.noString(parentType)) 8932 t = parent; 8933 else { 8934 t = parent.predicate("fhir:"+parentType+'.'+name); 8935 } 8936 composeBackboneElement(t, "component", name, element, index); 8937 if (element.hasCode()) 8938 composeCodeableConcept(t, "Observation", "code", element.getCode(), -1); 8939 if (element.hasValue()) 8940 composeType(t, "Observation", "value", element.getValue(), -1); 8941 if (element.hasDataAbsentReason()) 8942 composeCodeableConcept(t, "Observation", "dataAbsentReason", element.getDataAbsentReason(), -1); 8943 if (element.hasInterpretation()) 8944 composeCodeableConcept(t, "Observation", "interpretation", element.getInterpretation(), -1); 8945 for (int i = 0; i < element.getReferenceRange().size(); i++) 8946 composeObservationObservationReferenceRangeComponent(t, "Observation", "referenceRange", element.getReferenceRange().get(i), i); 8947 } 8948 8949 protected void composeOperationDefinition(Complex parent, String parentType, String name, OperationDefinition element, int index) { 8950 if (element == null) 8951 return; 8952 Complex t; 8953 if (Utilities.noString(parentType)) 8954 t = parent; 8955 else { 8956 t = parent.predicate("fhir:"+parentType+'.'+name); 8957 } 8958 composeDomainResource(t, "OperationDefinition", name, element, index); 8959 if (element.hasUrlElement()) 8960 composeUri(t, "OperationDefinition", "url", element.getUrlElement(), -1); 8961 if (element.hasVersionElement()) 8962 composeString(t, "OperationDefinition", "version", element.getVersionElement(), -1); 8963 if (element.hasNameElement()) 8964 composeString(t, "OperationDefinition", "name", element.getNameElement(), -1); 8965 if (element.hasStatusElement()) 8966 composeEnum(t, "OperationDefinition", "status", element.getStatusElement(), -1); 8967 if (element.hasKindElement()) 8968 composeEnum(t, "OperationDefinition", "kind", element.getKindElement(), -1); 8969 if (element.hasExperimentalElement()) 8970 composeBoolean(t, "OperationDefinition", "experimental", element.getExperimentalElement(), -1); 8971 if (element.hasDateElement()) 8972 composeDateTime(t, "OperationDefinition", "date", element.getDateElement(), -1); 8973 if (element.hasPublisherElement()) 8974 composeString(t, "OperationDefinition", "publisher", element.getPublisherElement(), -1); 8975 for (int i = 0; i < element.getContact().size(); i++) 8976 composeContactDetail(t, "OperationDefinition", "contact", element.getContact().get(i), i); 8977 if (element.hasDescriptionElement()) 8978 composeMarkdown(t, "OperationDefinition", "description", element.getDescriptionElement(), -1); 8979 for (int i = 0; i < element.getUseContext().size(); i++) 8980 composeUsageContext(t, "OperationDefinition", "useContext", element.getUseContext().get(i), i); 8981 for (int i = 0; i < element.getJurisdiction().size(); i++) 8982 composeCodeableConcept(t, "OperationDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 8983 if (element.hasPurposeElement()) 8984 composeMarkdown(t, "OperationDefinition", "purpose", element.getPurposeElement(), -1); 8985 if (element.hasIdempotentElement()) 8986 composeBoolean(t, "OperationDefinition", "idempotent", element.getIdempotentElement(), -1); 8987 if (element.hasCodeElement()) 8988 composeCode(t, "OperationDefinition", "code", element.getCodeElement(), -1); 8989 if (element.hasCommentElement()) 8990 composeString(t, "OperationDefinition", "comment", element.getCommentElement(), -1); 8991 if (element.hasBase()) 8992 composeReference(t, "OperationDefinition", "base", element.getBase(), -1); 8993 for (int i = 0; i < element.getResource().size(); i++) 8994 composeCode(t, "OperationDefinition", "resource", element.getResource().get(i), i); 8995 if (element.hasSystemElement()) 8996 composeBoolean(t, "OperationDefinition", "system", element.getSystemElement(), -1); 8997 if (element.hasTypeElement()) 8998 composeBoolean(t, "OperationDefinition", "type", element.getTypeElement(), -1); 8999 if (element.hasInstanceElement()) 9000 composeBoolean(t, "OperationDefinition", "instance", element.getInstanceElement(), -1); 9001 for (int i = 0; i < element.getParameter().size(); i++) 9002 composeOperationDefinitionOperationDefinitionParameterComponent(t, "OperationDefinition", "parameter", element.getParameter().get(i), i); 9003 for (int i = 0; i < element.getOverload().size(); i++) 9004 composeOperationDefinitionOperationDefinitionOverloadComponent(t, "OperationDefinition", "overload", element.getOverload().get(i), i); 9005 } 9006 9007 protected void composeOperationDefinitionOperationDefinitionParameterComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterComponent element, int index) { 9008 if (element == null) 9009 return; 9010 Complex t; 9011 if (Utilities.noString(parentType)) 9012 t = parent; 9013 else { 9014 t = parent.predicate("fhir:"+parentType+'.'+name); 9015 } 9016 composeBackboneElement(t, "parameter", name, element, index); 9017 if (element.hasNameElement()) 9018 composeCode(t, "OperationDefinition", "name", element.getNameElement(), -1); 9019 if (element.hasUseElement()) 9020 composeEnum(t, "OperationDefinition", "use", element.getUseElement(), -1); 9021 if (element.hasMinElement()) 9022 composeInteger(t, "OperationDefinition", "min", element.getMinElement(), -1); 9023 if (element.hasMaxElement()) 9024 composeString(t, "OperationDefinition", "max", element.getMaxElement(), -1); 9025 if (element.hasDocumentationElement()) 9026 composeString(t, "OperationDefinition", "documentation", element.getDocumentationElement(), -1); 9027 if (element.hasTypeElement()) 9028 composeCode(t, "OperationDefinition", "type", element.getTypeElement(), -1); 9029 if (element.hasSearchTypeElement()) 9030 composeEnum(t, "OperationDefinition", "searchType", element.getSearchTypeElement(), -1); 9031 if (element.hasProfile()) 9032 composeReference(t, "OperationDefinition", "profile", element.getProfile(), -1); 9033 if (element.hasBinding()) 9034 composeOperationDefinitionOperationDefinitionParameterBindingComponent(t, "OperationDefinition", "binding", element.getBinding(), -1); 9035 for (int i = 0; i < element.getPart().size(); i++) 9036 composeOperationDefinitionOperationDefinitionParameterComponent(t, "OperationDefinition", "part", element.getPart().get(i), i); 9037 } 9038 9039 protected void composeOperationDefinitionOperationDefinitionParameterBindingComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterBindingComponent element, int index) { 9040 if (element == null) 9041 return; 9042 Complex t; 9043 if (Utilities.noString(parentType)) 9044 t = parent; 9045 else { 9046 t = parent.predicate("fhir:"+parentType+'.'+name); 9047 } 9048 composeBackboneElement(t, "binding", name, element, index); 9049 if (element.hasStrengthElement()) 9050 composeEnum(t, "OperationDefinition", "strength", element.getStrengthElement(), -1); 9051 if (element.hasValueSet()) 9052 composeType(t, "OperationDefinition", "valueSet", element.getValueSet(), -1); 9053 } 9054 9055 protected void composeOperationDefinitionOperationDefinitionOverloadComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionOverloadComponent element, int index) { 9056 if (element == null) 9057 return; 9058 Complex t; 9059 if (Utilities.noString(parentType)) 9060 t = parent; 9061 else { 9062 t = parent.predicate("fhir:"+parentType+'.'+name); 9063 } 9064 composeBackboneElement(t, "overload", name, element, index); 9065 for (int i = 0; i < element.getParameterName().size(); i++) 9066 composeString(t, "OperationDefinition", "parameterName", element.getParameterName().get(i), i); 9067 if (element.hasCommentElement()) 9068 composeString(t, "OperationDefinition", "comment", element.getCommentElement(), -1); 9069 } 9070 9071 protected void composeOperationOutcome(Complex parent, String parentType, String name, OperationOutcome element, int index) { 9072 if (element == null) 9073 return; 9074 Complex t; 9075 if (Utilities.noString(parentType)) 9076 t = parent; 9077 else { 9078 t = parent.predicate("fhir:"+parentType+'.'+name); 9079 } 9080 composeDomainResource(t, "OperationOutcome", name, element, index); 9081 for (int i = 0; i < element.getIssue().size(); i++) 9082 composeOperationOutcomeOperationOutcomeIssueComponent(t, "OperationOutcome", "issue", element.getIssue().get(i), i); 9083 } 9084 9085 protected void composeOperationOutcomeOperationOutcomeIssueComponent(Complex parent, String parentType, String name, OperationOutcome.OperationOutcomeIssueComponent element, int index) { 9086 if (element == null) 9087 return; 9088 Complex t; 9089 if (Utilities.noString(parentType)) 9090 t = parent; 9091 else { 9092 t = parent.predicate("fhir:"+parentType+'.'+name); 9093 } 9094 composeBackboneElement(t, "issue", name, element, index); 9095 if (element.hasSeverityElement()) 9096 composeEnum(t, "OperationOutcome", "severity", element.getSeverityElement(), -1); 9097 if (element.hasCodeElement()) 9098 composeEnum(t, "OperationOutcome", "code", element.getCodeElement(), -1); 9099 if (element.hasDetails()) 9100 composeCodeableConcept(t, "OperationOutcome", "details", element.getDetails(), -1); 9101 if (element.hasDiagnosticsElement()) 9102 composeString(t, "OperationOutcome", "diagnostics", element.getDiagnosticsElement(), -1); 9103 for (int i = 0; i < element.getLocation().size(); i++) 9104 composeString(t, "OperationOutcome", "location", element.getLocation().get(i), i); 9105 for (int i = 0; i < element.getExpression().size(); i++) 9106 composeString(t, "OperationOutcome", "expression", element.getExpression().get(i), i); 9107 } 9108 9109 protected void composeOrganization(Complex parent, String parentType, String name, Organization element, int index) { 9110 if (element == null) 9111 return; 9112 Complex t; 9113 if (Utilities.noString(parentType)) 9114 t = parent; 9115 else { 9116 t = parent.predicate("fhir:"+parentType+'.'+name); 9117 } 9118 composeDomainResource(t, "Organization", name, element, index); 9119 for (int i = 0; i < element.getIdentifier().size(); i++) 9120 composeIdentifier(t, "Organization", "identifier", element.getIdentifier().get(i), i); 9121 if (element.hasActiveElement()) 9122 composeBoolean(t, "Organization", "active", element.getActiveElement(), -1); 9123 for (int i = 0; i < element.getType().size(); i++) 9124 composeCodeableConcept(t, "Organization", "type", element.getType().get(i), i); 9125 if (element.hasNameElement()) 9126 composeString(t, "Organization", "name", element.getNameElement(), -1); 9127 for (int i = 0; i < element.getAlias().size(); i++) 9128 composeString(t, "Organization", "alias", element.getAlias().get(i), i); 9129 for (int i = 0; i < element.getTelecom().size(); i++) 9130 composeContactPoint(t, "Organization", "telecom", element.getTelecom().get(i), i); 9131 for (int i = 0; i < element.getAddress().size(); i++) 9132 composeAddress(t, "Organization", "address", element.getAddress().get(i), i); 9133 if (element.hasPartOf()) 9134 composeReference(t, "Organization", "partOf", element.getPartOf(), -1); 9135 for (int i = 0; i < element.getContact().size(); i++) 9136 composeOrganizationOrganizationContactComponent(t, "Organization", "contact", element.getContact().get(i), i); 9137 for (int i = 0; i < element.getEndpoint().size(); i++) 9138 composeReference(t, "Organization", "endpoint", element.getEndpoint().get(i), i); 9139 } 9140 9141 protected void composeOrganizationOrganizationContactComponent(Complex parent, String parentType, String name, Organization.OrganizationContactComponent element, int index) { 9142 if (element == null) 9143 return; 9144 Complex t; 9145 if (Utilities.noString(parentType)) 9146 t = parent; 9147 else { 9148 t = parent.predicate("fhir:"+parentType+'.'+name); 9149 } 9150 composeBackboneElement(t, "contact", name, element, index); 9151 if (element.hasPurpose()) 9152 composeCodeableConcept(t, "Organization", "purpose", element.getPurpose(), -1); 9153 if (element.hasName()) 9154 composeHumanName(t, "Organization", "name", element.getName(), -1); 9155 for (int i = 0; i < element.getTelecom().size(); i++) 9156 composeContactPoint(t, "Organization", "telecom", element.getTelecom().get(i), i); 9157 if (element.hasAddress()) 9158 composeAddress(t, "Organization", "address", element.getAddress(), -1); 9159 } 9160 9161 protected void composePatient(Complex parent, String parentType, String name, Patient 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 composeDomainResource(t, "Patient", name, element, index); 9171 for (int i = 0; i < element.getIdentifier().size(); i++) 9172 composeIdentifier(t, "Patient", "identifier", element.getIdentifier().get(i), i); 9173 if (element.hasActiveElement()) 9174 composeBoolean(t, "Patient", "active", element.getActiveElement(), -1); 9175 for (int i = 0; i < element.getName().size(); i++) 9176 composeHumanName(t, "Patient", "name", element.getName().get(i), i); 9177 for (int i = 0; i < element.getTelecom().size(); i++) 9178 composeContactPoint(t, "Patient", "telecom", element.getTelecom().get(i), i); 9179 if (element.hasGenderElement()) 9180 composeEnum(t, "Patient", "gender", element.getGenderElement(), -1); 9181 if (element.hasBirthDateElement()) 9182 composeDate(t, "Patient", "birthDate", element.getBirthDateElement(), -1); 9183 if (element.hasDeceased()) 9184 composeType(t, "Patient", "deceased", element.getDeceased(), -1); 9185 for (int i = 0; i < element.getAddress().size(); i++) 9186 composeAddress(t, "Patient", "address", element.getAddress().get(i), i); 9187 if (element.hasMaritalStatus()) 9188 composeCodeableConcept(t, "Patient", "maritalStatus", element.getMaritalStatus(), -1); 9189 if (element.hasMultipleBirth()) 9190 composeType(t, "Patient", "multipleBirth", element.getMultipleBirth(), -1); 9191 for (int i = 0; i < element.getPhoto().size(); i++) 9192 composeAttachment(t, "Patient", "photo", element.getPhoto().get(i), i); 9193 for (int i = 0; i < element.getContact().size(); i++) 9194 composePatientContactComponent(t, "Patient", "contact", element.getContact().get(i), i); 9195 if (element.hasAnimal()) 9196 composePatientAnimalComponent(t, "Patient", "animal", element.getAnimal(), -1); 9197 for (int i = 0; i < element.getCommunication().size(); i++) 9198 composePatientPatientCommunicationComponent(t, "Patient", "communication", element.getCommunication().get(i), i); 9199 for (int i = 0; i < element.getGeneralPractitioner().size(); i++) 9200 composeReference(t, "Patient", "generalPractitioner", element.getGeneralPractitioner().get(i), i); 9201 if (element.hasManagingOrganization()) 9202 composeReference(t, "Patient", "managingOrganization", element.getManagingOrganization(), -1); 9203 for (int i = 0; i < element.getLink().size(); i++) 9204 composePatientPatientLinkComponent(t, "Patient", "link", element.getLink().get(i), i); 9205 } 9206 9207 protected void composePatientContactComponent(Complex parent, String parentType, String name, Patient.ContactComponent element, int index) { 9208 if (element == null) 9209 return; 9210 Complex t; 9211 if (Utilities.noString(parentType)) 9212 t = parent; 9213 else { 9214 t = parent.predicate("fhir:"+parentType+'.'+name); 9215 } 9216 composeBackboneElement(t, "contact", name, element, index); 9217 for (int i = 0; i < element.getRelationship().size(); i++) 9218 composeCodeableConcept(t, "Patient", "relationship", element.getRelationship().get(i), i); 9219 if (element.hasName()) 9220 composeHumanName(t, "Patient", "name", element.getName(), -1); 9221 for (int i = 0; i < element.getTelecom().size(); i++) 9222 composeContactPoint(t, "Patient", "telecom", element.getTelecom().get(i), i); 9223 if (element.hasAddress()) 9224 composeAddress(t, "Patient", "address", element.getAddress(), -1); 9225 if (element.hasGenderElement()) 9226 composeEnum(t, "Patient", "gender", element.getGenderElement(), -1); 9227 if (element.hasOrganization()) 9228 composeReference(t, "Patient", "organization", element.getOrganization(), -1); 9229 if (element.hasPeriod()) 9230 composePeriod(t, "Patient", "period", element.getPeriod(), -1); 9231 } 9232 9233 protected void composePatientAnimalComponent(Complex parent, String parentType, String name, Patient.AnimalComponent element, int index) { 9234 if (element == null) 9235 return; 9236 Complex t; 9237 if (Utilities.noString(parentType)) 9238 t = parent; 9239 else { 9240 t = parent.predicate("fhir:"+parentType+'.'+name); 9241 } 9242 composeBackboneElement(t, "animal", name, element, index); 9243 if (element.hasSpecies()) 9244 composeCodeableConcept(t, "Patient", "species", element.getSpecies(), -1); 9245 if (element.hasBreed()) 9246 composeCodeableConcept(t, "Patient", "breed", element.getBreed(), -1); 9247 if (element.hasGenderStatus()) 9248 composeCodeableConcept(t, "Patient", "genderStatus", element.getGenderStatus(), -1); 9249 } 9250 9251 protected void composePatientPatientCommunicationComponent(Complex parent, String parentType, String name, Patient.PatientCommunicationComponent element, int index) { 9252 if (element == null) 9253 return; 9254 Complex t; 9255 if (Utilities.noString(parentType)) 9256 t = parent; 9257 else { 9258 t = parent.predicate("fhir:"+parentType+'.'+name); 9259 } 9260 composeBackboneElement(t, "communication", name, element, index); 9261 if (element.hasLanguage()) 9262 composeCodeableConcept(t, "Patient", "language", element.getLanguage(), -1); 9263 if (element.hasPreferredElement()) 9264 composeBoolean(t, "Patient", "preferred", element.getPreferredElement(), -1); 9265 } 9266 9267 protected void composePatientPatientLinkComponent(Complex parent, String parentType, String name, Patient.PatientLinkComponent element, int index) { 9268 if (element == null) 9269 return; 9270 Complex t; 9271 if (Utilities.noString(parentType)) 9272 t = parent; 9273 else { 9274 t = parent.predicate("fhir:"+parentType+'.'+name); 9275 } 9276 composeBackboneElement(t, "link", name, element, index); 9277 if (element.hasOther()) 9278 composeReference(t, "Patient", "other", element.getOther(), -1); 9279 if (element.hasTypeElement()) 9280 composeEnum(t, "Patient", "type", element.getTypeElement(), -1); 9281 } 9282 9283 protected void composePaymentNotice(Complex parent, String parentType, String name, PaymentNotice element, int index) { 9284 if (element == null) 9285 return; 9286 Complex t; 9287 if (Utilities.noString(parentType)) 9288 t = parent; 9289 else { 9290 t = parent.predicate("fhir:"+parentType+'.'+name); 9291 } 9292 composeDomainResource(t, "PaymentNotice", name, element, index); 9293 for (int i = 0; i < element.getIdentifier().size(); i++) 9294 composeIdentifier(t, "PaymentNotice", "identifier", element.getIdentifier().get(i), i); 9295 if (element.hasStatusElement()) 9296 composeEnum(t, "PaymentNotice", "status", element.getStatusElement(), -1); 9297 if (element.hasRequest()) 9298 composeReference(t, "PaymentNotice", "request", element.getRequest(), -1); 9299 if (element.hasResponse()) 9300 composeReference(t, "PaymentNotice", "response", element.getResponse(), -1); 9301 if (element.hasStatusDateElement()) 9302 composeDate(t, "PaymentNotice", "statusDate", element.getStatusDateElement(), -1); 9303 if (element.hasCreatedElement()) 9304 composeDateTime(t, "PaymentNotice", "created", element.getCreatedElement(), -1); 9305 if (element.hasTarget()) 9306 composeReference(t, "PaymentNotice", "target", element.getTarget(), -1); 9307 if (element.hasProvider()) 9308 composeReference(t, "PaymentNotice", "provider", element.getProvider(), -1); 9309 if (element.hasOrganization()) 9310 composeReference(t, "PaymentNotice", "organization", element.getOrganization(), -1); 9311 if (element.hasPaymentStatus()) 9312 composeCodeableConcept(t, "PaymentNotice", "paymentStatus", element.getPaymentStatus(), -1); 9313 } 9314 9315 protected void composePaymentReconciliation(Complex parent, String parentType, String name, PaymentReconciliation element, int index) { 9316 if (element == null) 9317 return; 9318 Complex t; 9319 if (Utilities.noString(parentType)) 9320 t = parent; 9321 else { 9322 t = parent.predicate("fhir:"+parentType+'.'+name); 9323 } 9324 composeDomainResource(t, "PaymentReconciliation", name, element, index); 9325 for (int i = 0; i < element.getIdentifier().size(); i++) 9326 composeIdentifier(t, "PaymentReconciliation", "identifier", element.getIdentifier().get(i), i); 9327 if (element.hasStatusElement()) 9328 composeEnum(t, "PaymentReconciliation", "status", element.getStatusElement(), -1); 9329 if (element.hasPeriod()) 9330 composePeriod(t, "PaymentReconciliation", "period", element.getPeriod(), -1); 9331 if (element.hasCreatedElement()) 9332 composeDateTime(t, "PaymentReconciliation", "created", element.getCreatedElement(), -1); 9333 if (element.hasOrganization()) 9334 composeReference(t, "PaymentReconciliation", "organization", element.getOrganization(), -1); 9335 if (element.hasRequest()) 9336 composeReference(t, "PaymentReconciliation", "request", element.getRequest(), -1); 9337 if (element.hasOutcome()) 9338 composeCodeableConcept(t, "PaymentReconciliation", "outcome", element.getOutcome(), -1); 9339 if (element.hasDispositionElement()) 9340 composeString(t, "PaymentReconciliation", "disposition", element.getDispositionElement(), -1); 9341 if (element.hasRequestProvider()) 9342 composeReference(t, "PaymentReconciliation", "requestProvider", element.getRequestProvider(), -1); 9343 if (element.hasRequestOrganization()) 9344 composeReference(t, "PaymentReconciliation", "requestOrganization", element.getRequestOrganization(), -1); 9345 for (int i = 0; i < element.getDetail().size(); i++) 9346 composePaymentReconciliationDetailsComponent(t, "PaymentReconciliation", "detail", element.getDetail().get(i), i); 9347 if (element.hasForm()) 9348 composeCodeableConcept(t, "PaymentReconciliation", "form", element.getForm(), -1); 9349 if (element.hasTotal()) 9350 composeMoney(t, "PaymentReconciliation", "total", element.getTotal(), -1); 9351 for (int i = 0; i < element.getProcessNote().size(); i++) 9352 composePaymentReconciliationNotesComponent(t, "PaymentReconciliation", "processNote", element.getProcessNote().get(i), i); 9353 } 9354 9355 protected void composePaymentReconciliationDetailsComponent(Complex parent, String parentType, String name, PaymentReconciliation.DetailsComponent element, int index) { 9356 if (element == null) 9357 return; 9358 Complex t; 9359 if (Utilities.noString(parentType)) 9360 t = parent; 9361 else { 9362 t = parent.predicate("fhir:"+parentType+'.'+name); 9363 } 9364 composeBackboneElement(t, "detail", name, element, index); 9365 if (element.hasType()) 9366 composeCodeableConcept(t, "PaymentReconciliation", "type", element.getType(), -1); 9367 if (element.hasRequest()) 9368 composeReference(t, "PaymentReconciliation", "request", element.getRequest(), -1); 9369 if (element.hasResponse()) 9370 composeReference(t, "PaymentReconciliation", "response", element.getResponse(), -1); 9371 if (element.hasSubmitter()) 9372 composeReference(t, "PaymentReconciliation", "submitter", element.getSubmitter(), -1); 9373 if (element.hasPayee()) 9374 composeReference(t, "PaymentReconciliation", "payee", element.getPayee(), -1); 9375 if (element.hasDateElement()) 9376 composeDate(t, "PaymentReconciliation", "date", element.getDateElement(), -1); 9377 if (element.hasAmount()) 9378 composeMoney(t, "PaymentReconciliation", "amount", element.getAmount(), -1); 9379 } 9380 9381 protected void composePaymentReconciliationNotesComponent(Complex parent, String parentType, String name, PaymentReconciliation.NotesComponent element, int index) { 9382 if (element == null) 9383 return; 9384 Complex t; 9385 if (Utilities.noString(parentType)) 9386 t = parent; 9387 else { 9388 t = parent.predicate("fhir:"+parentType+'.'+name); 9389 } 9390 composeBackboneElement(t, "processNote", name, element, index); 9391 if (element.hasType()) 9392 composeCodeableConcept(t, "PaymentReconciliation", "type", element.getType(), -1); 9393 if (element.hasTextElement()) 9394 composeString(t, "PaymentReconciliation", "text", element.getTextElement(), -1); 9395 } 9396 9397 protected void composePerson(Complex parent, String parentType, String name, Person element, int index) { 9398 if (element == null) 9399 return; 9400 Complex t; 9401 if (Utilities.noString(parentType)) 9402 t = parent; 9403 else { 9404 t = parent.predicate("fhir:"+parentType+'.'+name); 9405 } 9406 composeDomainResource(t, "Person", name, element, index); 9407 for (int i = 0; i < element.getIdentifier().size(); i++) 9408 composeIdentifier(t, "Person", "identifier", element.getIdentifier().get(i), i); 9409 for (int i = 0; i < element.getName().size(); i++) 9410 composeHumanName(t, "Person", "name", element.getName().get(i), i); 9411 for (int i = 0; i < element.getTelecom().size(); i++) 9412 composeContactPoint(t, "Person", "telecom", element.getTelecom().get(i), i); 9413 if (element.hasGenderElement()) 9414 composeEnum(t, "Person", "gender", element.getGenderElement(), -1); 9415 if (element.hasBirthDateElement()) 9416 composeDate(t, "Person", "birthDate", element.getBirthDateElement(), -1); 9417 for (int i = 0; i < element.getAddress().size(); i++) 9418 composeAddress(t, "Person", "address", element.getAddress().get(i), i); 9419 if (element.hasPhoto()) 9420 composeAttachment(t, "Person", "photo", element.getPhoto(), -1); 9421 if (element.hasManagingOrganization()) 9422 composeReference(t, "Person", "managingOrganization", element.getManagingOrganization(), -1); 9423 if (element.hasActiveElement()) 9424 composeBoolean(t, "Person", "active", element.getActiveElement(), -1); 9425 for (int i = 0; i < element.getLink().size(); i++) 9426 composePersonPersonLinkComponent(t, "Person", "link", element.getLink().get(i), i); 9427 } 9428 9429 protected void composePersonPersonLinkComponent(Complex parent, String parentType, String name, Person.PersonLinkComponent element, int index) { 9430 if (element == null) 9431 return; 9432 Complex t; 9433 if (Utilities.noString(parentType)) 9434 t = parent; 9435 else { 9436 t = parent.predicate("fhir:"+parentType+'.'+name); 9437 } 9438 composeBackboneElement(t, "link", name, element, index); 9439 if (element.hasTarget()) 9440 composeReference(t, "Person", "target", element.getTarget(), -1); 9441 if (element.hasAssuranceElement()) 9442 composeEnum(t, "Person", "assurance", element.getAssuranceElement(), -1); 9443 } 9444 9445 protected void composePlanDefinition(Complex parent, String parentType, String name, PlanDefinition element, int index) { 9446 if (element == null) 9447 return; 9448 Complex t; 9449 if (Utilities.noString(parentType)) 9450 t = parent; 9451 else { 9452 t = parent.predicate("fhir:"+parentType+'.'+name); 9453 } 9454 composeDomainResource(t, "PlanDefinition", name, element, index); 9455 if (element.hasUrlElement()) 9456 composeUri(t, "PlanDefinition", "url", element.getUrlElement(), -1); 9457 for (int i = 0; i < element.getIdentifier().size(); i++) 9458 composeIdentifier(t, "PlanDefinition", "identifier", element.getIdentifier().get(i), i); 9459 if (element.hasVersionElement()) 9460 composeString(t, "PlanDefinition", "version", element.getVersionElement(), -1); 9461 if (element.hasNameElement()) 9462 composeString(t, "PlanDefinition", "name", element.getNameElement(), -1); 9463 if (element.hasTitleElement()) 9464 composeString(t, "PlanDefinition", "title", element.getTitleElement(), -1); 9465 if (element.hasType()) 9466 composeCodeableConcept(t, "PlanDefinition", "type", element.getType(), -1); 9467 if (element.hasStatusElement()) 9468 composeEnum(t, "PlanDefinition", "status", element.getStatusElement(), -1); 9469 if (element.hasExperimentalElement()) 9470 composeBoolean(t, "PlanDefinition", "experimental", element.getExperimentalElement(), -1); 9471 if (element.hasDateElement()) 9472 composeDateTime(t, "PlanDefinition", "date", element.getDateElement(), -1); 9473 if (element.hasPublisherElement()) 9474 composeString(t, "PlanDefinition", "publisher", element.getPublisherElement(), -1); 9475 if (element.hasDescriptionElement()) 9476 composeMarkdown(t, "PlanDefinition", "description", element.getDescriptionElement(), -1); 9477 if (element.hasPurposeElement()) 9478 composeMarkdown(t, "PlanDefinition", "purpose", element.getPurposeElement(), -1); 9479 if (element.hasUsageElement()) 9480 composeString(t, "PlanDefinition", "usage", element.getUsageElement(), -1); 9481 if (element.hasApprovalDateElement()) 9482 composeDate(t, "PlanDefinition", "approvalDate", element.getApprovalDateElement(), -1); 9483 if (element.hasLastReviewDateElement()) 9484 composeDate(t, "PlanDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 9485 if (element.hasEffectivePeriod()) 9486 composePeriod(t, "PlanDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 9487 for (int i = 0; i < element.getUseContext().size(); i++) 9488 composeUsageContext(t, "PlanDefinition", "useContext", element.getUseContext().get(i), i); 9489 for (int i = 0; i < element.getJurisdiction().size(); i++) 9490 composeCodeableConcept(t, "PlanDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 9491 for (int i = 0; i < element.getTopic().size(); i++) 9492 composeCodeableConcept(t, "PlanDefinition", "topic", element.getTopic().get(i), i); 9493 for (int i = 0; i < element.getContributor().size(); i++) 9494 composeContributor(t, "PlanDefinition", "contributor", element.getContributor().get(i), i); 9495 for (int i = 0; i < element.getContact().size(); i++) 9496 composeContactDetail(t, "PlanDefinition", "contact", element.getContact().get(i), i); 9497 if (element.hasCopyrightElement()) 9498 composeMarkdown(t, "PlanDefinition", "copyright", element.getCopyrightElement(), -1); 9499 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 9500 composeRelatedArtifact(t, "PlanDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 9501 for (int i = 0; i < element.getLibrary().size(); i++) 9502 composeReference(t, "PlanDefinition", "library", element.getLibrary().get(i), i); 9503 for (int i = 0; i < element.getGoal().size(); i++) 9504 composePlanDefinitionPlanDefinitionGoalComponent(t, "PlanDefinition", "goal", element.getGoal().get(i), i); 9505 for (int i = 0; i < element.getAction().size(); i++) 9506 composePlanDefinitionPlanDefinitionActionComponent(t, "PlanDefinition", "action", element.getAction().get(i), i); 9507 } 9508 9509 protected void composePlanDefinitionPlanDefinitionGoalComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionGoalComponent element, int index) { 9510 if (element == null) 9511 return; 9512 Complex t; 9513 if (Utilities.noString(parentType)) 9514 t = parent; 9515 else { 9516 t = parent.predicate("fhir:"+parentType+'.'+name); 9517 } 9518 composeBackboneElement(t, "goal", name, element, index); 9519 if (element.hasCategory()) 9520 composeCodeableConcept(t, "PlanDefinition", "category", element.getCategory(), -1); 9521 if (element.hasDescription()) 9522 composeCodeableConcept(t, "PlanDefinition", "description", element.getDescription(), -1); 9523 if (element.hasPriority()) 9524 composeCodeableConcept(t, "PlanDefinition", "priority", element.getPriority(), -1); 9525 if (element.hasStart()) 9526 composeCodeableConcept(t, "PlanDefinition", "start", element.getStart(), -1); 9527 for (int i = 0; i < element.getAddresses().size(); i++) 9528 composeCodeableConcept(t, "PlanDefinition", "addresses", element.getAddresses().get(i), i); 9529 for (int i = 0; i < element.getDocumentation().size(); i++) 9530 composeRelatedArtifact(t, "PlanDefinition", "documentation", element.getDocumentation().get(i), i); 9531 for (int i = 0; i < element.getTarget().size(); i++) 9532 composePlanDefinitionPlanDefinitionGoalTargetComponent(t, "PlanDefinition", "target", element.getTarget().get(i), i); 9533 } 9534 9535 protected void composePlanDefinitionPlanDefinitionGoalTargetComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionGoalTargetComponent element, int index) { 9536 if (element == null) 9537 return; 9538 Complex t; 9539 if (Utilities.noString(parentType)) 9540 t = parent; 9541 else { 9542 t = parent.predicate("fhir:"+parentType+'.'+name); 9543 } 9544 composeBackboneElement(t, "target", name, element, index); 9545 if (element.hasMeasure()) 9546 composeCodeableConcept(t, "PlanDefinition", "measure", element.getMeasure(), -1); 9547 if (element.hasDetail()) 9548 composeType(t, "PlanDefinition", "detail", element.getDetail(), -1); 9549 if (element.hasDue()) 9550 composeDuration(t, "PlanDefinition", "due", element.getDue(), -1); 9551 } 9552 9553 protected void composePlanDefinitionPlanDefinitionActionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionComponent element, int index) { 9554 if (element == null) 9555 return; 9556 Complex t; 9557 if (Utilities.noString(parentType)) 9558 t = parent; 9559 else { 9560 t = parent.predicate("fhir:"+parentType+'.'+name); 9561 } 9562 composeBackboneElement(t, "action", name, element, index); 9563 if (element.hasLabelElement()) 9564 composeString(t, "PlanDefinition", "label", element.getLabelElement(), -1); 9565 if (element.hasTitleElement()) 9566 composeString(t, "PlanDefinition", "title", element.getTitleElement(), -1); 9567 if (element.hasDescriptionElement()) 9568 composeString(t, "PlanDefinition", "description", element.getDescriptionElement(), -1); 9569 if (element.hasTextEquivalentElement()) 9570 composeString(t, "PlanDefinition", "textEquivalent", element.getTextEquivalentElement(), -1); 9571 for (int i = 0; i < element.getCode().size(); i++) 9572 composeCodeableConcept(t, "PlanDefinition", "code", element.getCode().get(i), i); 9573 for (int i = 0; i < element.getReason().size(); i++) 9574 composeCodeableConcept(t, "PlanDefinition", "reason", element.getReason().get(i), i); 9575 for (int i = 0; i < element.getDocumentation().size(); i++) 9576 composeRelatedArtifact(t, "PlanDefinition", "documentation", element.getDocumentation().get(i), i); 9577 for (int i = 0; i < element.getGoalId().size(); i++) 9578 composeId(t, "PlanDefinition", "goalId", element.getGoalId().get(i), i); 9579 for (int i = 0; i < element.getTriggerDefinition().size(); i++) 9580 composeTriggerDefinition(t, "PlanDefinition", "triggerDefinition", element.getTriggerDefinition().get(i), i); 9581 for (int i = 0; i < element.getCondition().size(); i++) 9582 composePlanDefinitionPlanDefinitionActionConditionComponent(t, "PlanDefinition", "condition", element.getCondition().get(i), i); 9583 for (int i = 0; i < element.getInput().size(); i++) 9584 composeDataRequirement(t, "PlanDefinition", "input", element.getInput().get(i), i); 9585 for (int i = 0; i < element.getOutput().size(); i++) 9586 composeDataRequirement(t, "PlanDefinition", "output", element.getOutput().get(i), i); 9587 for (int i = 0; i < element.getRelatedAction().size(); i++) 9588 composePlanDefinitionPlanDefinitionActionRelatedActionComponent(t, "PlanDefinition", "relatedAction", element.getRelatedAction().get(i), i); 9589 if (element.hasTiming()) 9590 composeType(t, "PlanDefinition", "timing", element.getTiming(), -1); 9591 for (int i = 0; i < element.getParticipant().size(); i++) 9592 composePlanDefinitionPlanDefinitionActionParticipantComponent(t, "PlanDefinition", "participant", element.getParticipant().get(i), i); 9593 if (element.hasType()) 9594 composeCoding(t, "PlanDefinition", "type", element.getType(), -1); 9595 if (element.hasGroupingBehaviorElement()) 9596 composeEnum(t, "PlanDefinition", "groupingBehavior", element.getGroupingBehaviorElement(), -1); 9597 if (element.hasSelectionBehaviorElement()) 9598 composeEnum(t, "PlanDefinition", "selectionBehavior", element.getSelectionBehaviorElement(), -1); 9599 if (element.hasRequiredBehaviorElement()) 9600 composeEnum(t, "PlanDefinition", "requiredBehavior", element.getRequiredBehaviorElement(), -1); 9601 if (element.hasPrecheckBehaviorElement()) 9602 composeEnum(t, "PlanDefinition", "precheckBehavior", element.getPrecheckBehaviorElement(), -1); 9603 if (element.hasCardinalityBehaviorElement()) 9604 composeEnum(t, "PlanDefinition", "cardinalityBehavior", element.getCardinalityBehaviorElement(), -1); 9605 if (element.hasDefinition()) 9606 composeReference(t, "PlanDefinition", "definition", element.getDefinition(), -1); 9607 if (element.hasTransform()) 9608 composeReference(t, "PlanDefinition", "transform", element.getTransform(), -1); 9609 for (int i = 0; i < element.getDynamicValue().size(); i++) 9610 composePlanDefinitionPlanDefinitionActionDynamicValueComponent(t, "PlanDefinition", "dynamicValue", element.getDynamicValue().get(i), i); 9611 for (int i = 0; i < element.getAction().size(); i++) 9612 composePlanDefinitionPlanDefinitionActionComponent(t, "PlanDefinition", "action", element.getAction().get(i), i); 9613 } 9614 9615 protected void composePlanDefinitionPlanDefinitionActionConditionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionConditionComponent element, int index) { 9616 if (element == null) 9617 return; 9618 Complex t; 9619 if (Utilities.noString(parentType)) 9620 t = parent; 9621 else { 9622 t = parent.predicate("fhir:"+parentType+'.'+name); 9623 } 9624 composeBackboneElement(t, "condition", name, element, index); 9625 if (element.hasKindElement()) 9626 composeEnum(t, "PlanDefinition", "kind", element.getKindElement(), -1); 9627 if (element.hasDescriptionElement()) 9628 composeString(t, "PlanDefinition", "description", element.getDescriptionElement(), -1); 9629 if (element.hasLanguageElement()) 9630 composeString(t, "PlanDefinition", "language", element.getLanguageElement(), -1); 9631 if (element.hasExpressionElement()) 9632 composeString(t, "PlanDefinition", "expression", element.getExpressionElement(), -1); 9633 } 9634 9635 protected void composePlanDefinitionPlanDefinitionActionRelatedActionComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionRelatedActionComponent 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, "relatedAction", name, element, index); 9645 if (element.hasActionIdElement()) 9646 composeId(t, "PlanDefinition", "actionId", element.getActionIdElement(), -1); 9647 if (element.hasRelationshipElement()) 9648 composeEnum(t, "PlanDefinition", "relationship", element.getRelationshipElement(), -1); 9649 if (element.hasOffset()) 9650 composeType(t, "PlanDefinition", "offset", element.getOffset(), -1); 9651 } 9652 9653 protected void composePlanDefinitionPlanDefinitionActionParticipantComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionParticipantComponent element, int index) { 9654 if (element == null) 9655 return; 9656 Complex t; 9657 if (Utilities.noString(parentType)) 9658 t = parent; 9659 else { 9660 t = parent.predicate("fhir:"+parentType+'.'+name); 9661 } 9662 composeBackboneElement(t, "participant", name, element, index); 9663 if (element.hasTypeElement()) 9664 composeEnum(t, "PlanDefinition", "type", element.getTypeElement(), -1); 9665 if (element.hasRole()) 9666 composeCodeableConcept(t, "PlanDefinition", "role", element.getRole(), -1); 9667 } 9668 9669 protected void composePlanDefinitionPlanDefinitionActionDynamicValueComponent(Complex parent, String parentType, String name, PlanDefinition.PlanDefinitionActionDynamicValueComponent element, int index) { 9670 if (element == null) 9671 return; 9672 Complex t; 9673 if (Utilities.noString(parentType)) 9674 t = parent; 9675 else { 9676 t = parent.predicate("fhir:"+parentType+'.'+name); 9677 } 9678 composeBackboneElement(t, "dynamicValue", name, element, index); 9679 if (element.hasDescriptionElement()) 9680 composeString(t, "PlanDefinition", "description", element.getDescriptionElement(), -1); 9681 if (element.hasPathElement()) 9682 composeString(t, "PlanDefinition", "path", element.getPathElement(), -1); 9683 if (element.hasLanguageElement()) 9684 composeString(t, "PlanDefinition", "language", element.getLanguageElement(), -1); 9685 if (element.hasExpressionElement()) 9686 composeString(t, "PlanDefinition", "expression", element.getExpressionElement(), -1); 9687 } 9688 9689 protected void composePractitioner(Complex parent, String parentType, String name, Practitioner 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 composeDomainResource(t, "Practitioner", name, element, index); 9699 for (int i = 0; i < element.getIdentifier().size(); i++) 9700 composeIdentifier(t, "Practitioner", "identifier", element.getIdentifier().get(i), i); 9701 if (element.hasActiveElement()) 9702 composeBoolean(t, "Practitioner", "active", element.getActiveElement(), -1); 9703 for (int i = 0; i < element.getName().size(); i++) 9704 composeHumanName(t, "Practitioner", "name", element.getName().get(i), i); 9705 for (int i = 0; i < element.getTelecom().size(); i++) 9706 composeContactPoint(t, "Practitioner", "telecom", element.getTelecom().get(i), i); 9707 for (int i = 0; i < element.getAddress().size(); i++) 9708 composeAddress(t, "Practitioner", "address", element.getAddress().get(i), i); 9709 if (element.hasGenderElement()) 9710 composeEnum(t, "Practitioner", "gender", element.getGenderElement(), -1); 9711 if (element.hasBirthDateElement()) 9712 composeDate(t, "Practitioner", "birthDate", element.getBirthDateElement(), -1); 9713 for (int i = 0; i < element.getPhoto().size(); i++) 9714 composeAttachment(t, "Practitioner", "photo", element.getPhoto().get(i), i); 9715 for (int i = 0; i < element.getQualification().size(); i++) 9716 composePractitionerPractitionerQualificationComponent(t, "Practitioner", "qualification", element.getQualification().get(i), i); 9717 for (int i = 0; i < element.getCommunication().size(); i++) 9718 composeCodeableConcept(t, "Practitioner", "communication", element.getCommunication().get(i), i); 9719 } 9720 9721 protected void composePractitionerPractitionerQualificationComponent(Complex parent, String parentType, String name, Practitioner.PractitionerQualificationComponent element, int index) { 9722 if (element == null) 9723 return; 9724 Complex t; 9725 if (Utilities.noString(parentType)) 9726 t = parent; 9727 else { 9728 t = parent.predicate("fhir:"+parentType+'.'+name); 9729 } 9730 composeBackboneElement(t, "qualification", name, element, index); 9731 for (int i = 0; i < element.getIdentifier().size(); i++) 9732 composeIdentifier(t, "Practitioner", "identifier", element.getIdentifier().get(i), i); 9733 if (element.hasCode()) 9734 composeCodeableConcept(t, "Practitioner", "code", element.getCode(), -1); 9735 if (element.hasPeriod()) 9736 composePeriod(t, "Practitioner", "period", element.getPeriod(), -1); 9737 if (element.hasIssuer()) 9738 composeReference(t, "Practitioner", "issuer", element.getIssuer(), -1); 9739 } 9740 9741 protected void composePractitionerRole(Complex parent, String parentType, String name, PractitionerRole 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 composeDomainResource(t, "PractitionerRole", name, element, index); 9751 for (int i = 0; i < element.getIdentifier().size(); i++) 9752 composeIdentifier(t, "PractitionerRole", "identifier", element.getIdentifier().get(i), i); 9753 if (element.hasActiveElement()) 9754 composeBoolean(t, "PractitionerRole", "active", element.getActiveElement(), -1); 9755 if (element.hasPeriod()) 9756 composePeriod(t, "PractitionerRole", "period", element.getPeriod(), -1); 9757 if (element.hasPractitioner()) 9758 composeReference(t, "PractitionerRole", "practitioner", element.getPractitioner(), -1); 9759 if (element.hasOrganization()) 9760 composeReference(t, "PractitionerRole", "organization", element.getOrganization(), -1); 9761 for (int i = 0; i < element.getCode().size(); i++) 9762 composeCodeableConcept(t, "PractitionerRole", "code", element.getCode().get(i), i); 9763 for (int i = 0; i < element.getSpecialty().size(); i++) 9764 composeCodeableConcept(t, "PractitionerRole", "specialty", element.getSpecialty().get(i), i); 9765 for (int i = 0; i < element.getLocation().size(); i++) 9766 composeReference(t, "PractitionerRole", "location", element.getLocation().get(i), i); 9767 for (int i = 0; i < element.getHealthcareService().size(); i++) 9768 composeReference(t, "PractitionerRole", "healthcareService", element.getHealthcareService().get(i), i); 9769 for (int i = 0; i < element.getTelecom().size(); i++) 9770 composeContactPoint(t, "PractitionerRole", "telecom", element.getTelecom().get(i), i); 9771 for (int i = 0; i < element.getAvailableTime().size(); i++) 9772 composePractitionerRolePractitionerRoleAvailableTimeComponent(t, "PractitionerRole", "availableTime", element.getAvailableTime().get(i), i); 9773 for (int i = 0; i < element.getNotAvailable().size(); i++) 9774 composePractitionerRolePractitionerRoleNotAvailableComponent(t, "PractitionerRole", "notAvailable", element.getNotAvailable().get(i), i); 9775 if (element.hasAvailabilityExceptionsElement()) 9776 composeString(t, "PractitionerRole", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1); 9777 for (int i = 0; i < element.getEndpoint().size(); i++) 9778 composeReference(t, "PractitionerRole", "endpoint", element.getEndpoint().get(i), i); 9779 } 9780 9781 protected void composePractitionerRolePractitionerRoleAvailableTimeComponent(Complex parent, String parentType, String name, PractitionerRole.PractitionerRoleAvailableTimeComponent element, int index) { 9782 if (element == null) 9783 return; 9784 Complex t; 9785 if (Utilities.noString(parentType)) 9786 t = parent; 9787 else { 9788 t = parent.predicate("fhir:"+parentType+'.'+name); 9789 } 9790 composeBackboneElement(t, "availableTime", name, element, index); 9791 for (int i = 0; i < element.getDaysOfWeek().size(); i++) 9792 composeEnum(t, "PractitionerRole", "daysOfWeek", element.getDaysOfWeek().get(i), i); 9793 if (element.hasAllDayElement()) 9794 composeBoolean(t, "PractitionerRole", "allDay", element.getAllDayElement(), -1); 9795 if (element.hasAvailableStartTimeElement()) 9796 composeTime(t, "PractitionerRole", "availableStartTime", element.getAvailableStartTimeElement(), -1); 9797 if (element.hasAvailableEndTimeElement()) 9798 composeTime(t, "PractitionerRole", "availableEndTime", element.getAvailableEndTimeElement(), -1); 9799 } 9800 9801 protected void composePractitionerRolePractitionerRoleNotAvailableComponent(Complex parent, String parentType, String name, PractitionerRole.PractitionerRoleNotAvailableComponent 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, "notAvailable", name, element, index); 9811 if (element.hasDescriptionElement()) 9812 composeString(t, "PractitionerRole", "description", element.getDescriptionElement(), -1); 9813 if (element.hasDuring()) 9814 composePeriod(t, "PractitionerRole", "during", element.getDuring(), -1); 9815 } 9816 9817 protected void composeProcedure(Complex parent, String parentType, String name, Procedure element, int index) { 9818 if (element == null) 9819 return; 9820 Complex t; 9821 if (Utilities.noString(parentType)) 9822 t = parent; 9823 else { 9824 t = parent.predicate("fhir:"+parentType+'.'+name); 9825 } 9826 composeDomainResource(t, "Procedure", name, element, index); 9827 for (int i = 0; i < element.getIdentifier().size(); i++) 9828 composeIdentifier(t, "Procedure", "identifier", element.getIdentifier().get(i), i); 9829 for (int i = 0; i < element.getDefinition().size(); i++) 9830 composeReference(t, "Procedure", "definition", element.getDefinition().get(i), i); 9831 for (int i = 0; i < element.getBasedOn().size(); i++) 9832 composeReference(t, "Procedure", "basedOn", element.getBasedOn().get(i), i); 9833 for (int i = 0; i < element.getPartOf().size(); i++) 9834 composeReference(t, "Procedure", "partOf", element.getPartOf().get(i), i); 9835 if (element.hasStatusElement()) 9836 composeEnum(t, "Procedure", "status", element.getStatusElement(), -1); 9837 if (element.hasNotDoneElement()) 9838 composeBoolean(t, "Procedure", "notDone", element.getNotDoneElement(), -1); 9839 if (element.hasNotDoneReason()) 9840 composeCodeableConcept(t, "Procedure", "notDoneReason", element.getNotDoneReason(), -1); 9841 if (element.hasCategory()) 9842 composeCodeableConcept(t, "Procedure", "category", element.getCategory(), -1); 9843 if (element.hasCode()) 9844 composeCodeableConcept(t, "Procedure", "code", element.getCode(), -1); 9845 if (element.hasSubject()) 9846 composeReference(t, "Procedure", "subject", element.getSubject(), -1); 9847 if (element.hasContext()) 9848 composeReference(t, "Procedure", "context", element.getContext(), -1); 9849 if (element.hasPerformed()) 9850 composeType(t, "Procedure", "performed", element.getPerformed(), -1); 9851 for (int i = 0; i < element.getPerformer().size(); i++) 9852 composeProcedureProcedurePerformerComponent(t, "Procedure", "performer", element.getPerformer().get(i), i); 9853 if (element.hasLocation()) 9854 composeReference(t, "Procedure", "location", element.getLocation(), -1); 9855 for (int i = 0; i < element.getReasonCode().size(); i++) 9856 composeCodeableConcept(t, "Procedure", "reasonCode", element.getReasonCode().get(i), i); 9857 for (int i = 0; i < element.getReasonReference().size(); i++) 9858 composeReference(t, "Procedure", "reasonReference", element.getReasonReference().get(i), i); 9859 for (int i = 0; i < element.getBodySite().size(); i++) 9860 composeCodeableConcept(t, "Procedure", "bodySite", element.getBodySite().get(i), i); 9861 if (element.hasOutcome()) 9862 composeCodeableConcept(t, "Procedure", "outcome", element.getOutcome(), -1); 9863 for (int i = 0; i < element.getReport().size(); i++) 9864 composeReference(t, "Procedure", "report", element.getReport().get(i), i); 9865 for (int i = 0; i < element.getComplication().size(); i++) 9866 composeCodeableConcept(t, "Procedure", "complication", element.getComplication().get(i), i); 9867 for (int i = 0; i < element.getComplicationDetail().size(); i++) 9868 composeReference(t, "Procedure", "complicationDetail", element.getComplicationDetail().get(i), i); 9869 for (int i = 0; i < element.getFollowUp().size(); i++) 9870 composeCodeableConcept(t, "Procedure", "followUp", element.getFollowUp().get(i), i); 9871 for (int i = 0; i < element.getNote().size(); i++) 9872 composeAnnotation(t, "Procedure", "note", element.getNote().get(i), i); 9873 for (int i = 0; i < element.getFocalDevice().size(); i++) 9874 composeProcedureProcedureFocalDeviceComponent(t, "Procedure", "focalDevice", element.getFocalDevice().get(i), i); 9875 for (int i = 0; i < element.getUsedReference().size(); i++) 9876 composeReference(t, "Procedure", "usedReference", element.getUsedReference().get(i), i); 9877 for (int i = 0; i < element.getUsedCode().size(); i++) 9878 composeCodeableConcept(t, "Procedure", "usedCode", element.getUsedCode().get(i), i); 9879 } 9880 9881 protected void composeProcedureProcedurePerformerComponent(Complex parent, String parentType, String name, Procedure.ProcedurePerformerComponent element, int index) { 9882 if (element == null) 9883 return; 9884 Complex t; 9885 if (Utilities.noString(parentType)) 9886 t = parent; 9887 else { 9888 t = parent.predicate("fhir:"+parentType+'.'+name); 9889 } 9890 composeBackboneElement(t, "performer", name, element, index); 9891 if (element.hasRole()) 9892 composeCodeableConcept(t, "Procedure", "role", element.getRole(), -1); 9893 if (element.hasActor()) 9894 composeReference(t, "Procedure", "actor", element.getActor(), -1); 9895 if (element.hasOnBehalfOf()) 9896 composeReference(t, "Procedure", "onBehalfOf", element.getOnBehalfOf(), -1); 9897 } 9898 9899 protected void composeProcedureProcedureFocalDeviceComponent(Complex parent, String parentType, String name, Procedure.ProcedureFocalDeviceComponent element, int index) { 9900 if (element == null) 9901 return; 9902 Complex t; 9903 if (Utilities.noString(parentType)) 9904 t = parent; 9905 else { 9906 t = parent.predicate("fhir:"+parentType+'.'+name); 9907 } 9908 composeBackboneElement(t, "focalDevice", name, element, index); 9909 if (element.hasAction()) 9910 composeCodeableConcept(t, "Procedure", "action", element.getAction(), -1); 9911 if (element.hasManipulated()) 9912 composeReference(t, "Procedure", "manipulated", element.getManipulated(), -1); 9913 } 9914 9915 protected void composeProcedureRequest(Complex parent, String parentType, String name, ProcedureRequest element, int index) { 9916 if (element == null) 9917 return; 9918 Complex t; 9919 if (Utilities.noString(parentType)) 9920 t = parent; 9921 else { 9922 t = parent.predicate("fhir:"+parentType+'.'+name); 9923 } 9924 composeDomainResource(t, "ProcedureRequest", name, element, index); 9925 for (int i = 0; i < element.getIdentifier().size(); i++) 9926 composeIdentifier(t, "ProcedureRequest", "identifier", element.getIdentifier().get(i), i); 9927 for (int i = 0; i < element.getDefinition().size(); i++) 9928 composeReference(t, "ProcedureRequest", "definition", element.getDefinition().get(i), i); 9929 for (int i = 0; i < element.getBasedOn().size(); i++) 9930 composeReference(t, "ProcedureRequest", "basedOn", element.getBasedOn().get(i), i); 9931 for (int i = 0; i < element.getReplaces().size(); i++) 9932 composeReference(t, "ProcedureRequest", "replaces", element.getReplaces().get(i), i); 9933 if (element.hasRequisition()) 9934 composeIdentifier(t, "ProcedureRequest", "requisition", element.getRequisition(), -1); 9935 if (element.hasStatusElement()) 9936 composeEnum(t, "ProcedureRequest", "status", element.getStatusElement(), -1); 9937 if (element.hasIntentElement()) 9938 composeEnum(t, "ProcedureRequest", "intent", element.getIntentElement(), -1); 9939 if (element.hasPriorityElement()) 9940 composeEnum(t, "ProcedureRequest", "priority", element.getPriorityElement(), -1); 9941 if (element.hasDoNotPerformElement()) 9942 composeBoolean(t, "ProcedureRequest", "doNotPerform", element.getDoNotPerformElement(), -1); 9943 for (int i = 0; i < element.getCategory().size(); i++) 9944 composeCodeableConcept(t, "ProcedureRequest", "category", element.getCategory().get(i), i); 9945 if (element.hasCode()) 9946 composeCodeableConcept(t, "ProcedureRequest", "code", element.getCode(), -1); 9947 if (element.hasSubject()) 9948 composeReference(t, "ProcedureRequest", "subject", element.getSubject(), -1); 9949 if (element.hasContext()) 9950 composeReference(t, "ProcedureRequest", "context", element.getContext(), -1); 9951 if (element.hasOccurrence()) 9952 composeType(t, "ProcedureRequest", "occurrence", element.getOccurrence(), -1); 9953 if (element.hasAsNeeded()) 9954 composeType(t, "ProcedureRequest", "asNeeded", element.getAsNeeded(), -1); 9955 if (element.hasAuthoredOnElement()) 9956 composeDateTime(t, "ProcedureRequest", "authoredOn", element.getAuthoredOnElement(), -1); 9957 if (element.hasRequester()) 9958 composeProcedureRequestProcedureRequestRequesterComponent(t, "ProcedureRequest", "requester", element.getRequester(), -1); 9959 if (element.hasPerformerType()) 9960 composeCodeableConcept(t, "ProcedureRequest", "performerType", element.getPerformerType(), -1); 9961 if (element.hasPerformer()) 9962 composeReference(t, "ProcedureRequest", "performer", element.getPerformer(), -1); 9963 for (int i = 0; i < element.getReasonCode().size(); i++) 9964 composeCodeableConcept(t, "ProcedureRequest", "reasonCode", element.getReasonCode().get(i), i); 9965 for (int i = 0; i < element.getReasonReference().size(); i++) 9966 composeReference(t, "ProcedureRequest", "reasonReference", element.getReasonReference().get(i), i); 9967 for (int i = 0; i < element.getSupportingInfo().size(); i++) 9968 composeReference(t, "ProcedureRequest", "supportingInfo", element.getSupportingInfo().get(i), i); 9969 for (int i = 0; i < element.getSpecimen().size(); i++) 9970 composeReference(t, "ProcedureRequest", "specimen", element.getSpecimen().get(i), i); 9971 for (int i = 0; i < element.getBodySite().size(); i++) 9972 composeCodeableConcept(t, "ProcedureRequest", "bodySite", element.getBodySite().get(i), i); 9973 for (int i = 0; i < element.getNote().size(); i++) 9974 composeAnnotation(t, "ProcedureRequest", "note", element.getNote().get(i), i); 9975 for (int i = 0; i < element.getRelevantHistory().size(); i++) 9976 composeReference(t, "ProcedureRequest", "relevantHistory", element.getRelevantHistory().get(i), i); 9977 } 9978 9979 protected void composeProcedureRequestProcedureRequestRequesterComponent(Complex parent, String parentType, String name, ProcedureRequest.ProcedureRequestRequesterComponent element, int index) { 9980 if (element == null) 9981 return; 9982 Complex t; 9983 if (Utilities.noString(parentType)) 9984 t = parent; 9985 else { 9986 t = parent.predicate("fhir:"+parentType+'.'+name); 9987 } 9988 composeBackboneElement(t, "requester", name, element, index); 9989 if (element.hasAgent()) 9990 composeReference(t, "ProcedureRequest", "agent", element.getAgent(), -1); 9991 if (element.hasOnBehalfOf()) 9992 composeReference(t, "ProcedureRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 9993 } 9994 9995 protected void composeProcessRequest(Complex parent, String parentType, String name, ProcessRequest element, int index) { 9996 if (element == null) 9997 return; 9998 Complex t; 9999 if (Utilities.noString(parentType)) 10000 t = parent; 10001 else { 10002 t = parent.predicate("fhir:"+parentType+'.'+name); 10003 } 10004 composeDomainResource(t, "ProcessRequest", name, element, index); 10005 for (int i = 0; i < element.getIdentifier().size(); i++) 10006 composeIdentifier(t, "ProcessRequest", "identifier", element.getIdentifier().get(i), i); 10007 if (element.hasStatusElement()) 10008 composeEnum(t, "ProcessRequest", "status", element.getStatusElement(), -1); 10009 if (element.hasActionElement()) 10010 composeEnum(t, "ProcessRequest", "action", element.getActionElement(), -1); 10011 if (element.hasTarget()) 10012 composeReference(t, "ProcessRequest", "target", element.getTarget(), -1); 10013 if (element.hasCreatedElement()) 10014 composeDateTime(t, "ProcessRequest", "created", element.getCreatedElement(), -1); 10015 if (element.hasProvider()) 10016 composeReference(t, "ProcessRequest", "provider", element.getProvider(), -1); 10017 if (element.hasOrganization()) 10018 composeReference(t, "ProcessRequest", "organization", element.getOrganization(), -1); 10019 if (element.hasRequest()) 10020 composeReference(t, "ProcessRequest", "request", element.getRequest(), -1); 10021 if (element.hasResponse()) 10022 composeReference(t, "ProcessRequest", "response", element.getResponse(), -1); 10023 if (element.hasNullifyElement()) 10024 composeBoolean(t, "ProcessRequest", "nullify", element.getNullifyElement(), -1); 10025 if (element.hasReferenceElement()) 10026 composeString(t, "ProcessRequest", "reference", element.getReferenceElement(), -1); 10027 for (int i = 0; i < element.getItem().size(); i++) 10028 composeProcessRequestItemsComponent(t, "ProcessRequest", "item", element.getItem().get(i), i); 10029 for (int i = 0; i < element.getInclude().size(); i++) 10030 composeString(t, "ProcessRequest", "include", element.getInclude().get(i), i); 10031 for (int i = 0; i < element.getExclude().size(); i++) 10032 composeString(t, "ProcessRequest", "exclude", element.getExclude().get(i), i); 10033 if (element.hasPeriod()) 10034 composePeriod(t, "ProcessRequest", "period", element.getPeriod(), -1); 10035 } 10036 10037 protected void composeProcessRequestItemsComponent(Complex parent, String parentType, String name, ProcessRequest.ItemsComponent element, int index) { 10038 if (element == null) 10039 return; 10040 Complex t; 10041 if (Utilities.noString(parentType)) 10042 t = parent; 10043 else { 10044 t = parent.predicate("fhir:"+parentType+'.'+name); 10045 } 10046 composeBackboneElement(t, "item", name, element, index); 10047 if (element.hasSequenceLinkIdElement()) 10048 composeInteger(t, "ProcessRequest", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 10049 } 10050 10051 protected void composeProcessResponse(Complex parent, String parentType, String name, ProcessResponse element, int index) { 10052 if (element == null) 10053 return; 10054 Complex t; 10055 if (Utilities.noString(parentType)) 10056 t = parent; 10057 else { 10058 t = parent.predicate("fhir:"+parentType+'.'+name); 10059 } 10060 composeDomainResource(t, "ProcessResponse", name, element, index); 10061 for (int i = 0; i < element.getIdentifier().size(); i++) 10062 composeIdentifier(t, "ProcessResponse", "identifier", element.getIdentifier().get(i), i); 10063 if (element.hasStatusElement()) 10064 composeEnum(t, "ProcessResponse", "status", element.getStatusElement(), -1); 10065 if (element.hasCreatedElement()) 10066 composeDateTime(t, "ProcessResponse", "created", element.getCreatedElement(), -1); 10067 if (element.hasOrganization()) 10068 composeReference(t, "ProcessResponse", "organization", element.getOrganization(), -1); 10069 if (element.hasRequest()) 10070 composeReference(t, "ProcessResponse", "request", element.getRequest(), -1); 10071 if (element.hasOutcome()) 10072 composeCodeableConcept(t, "ProcessResponse", "outcome", element.getOutcome(), -1); 10073 if (element.hasDispositionElement()) 10074 composeString(t, "ProcessResponse", "disposition", element.getDispositionElement(), -1); 10075 if (element.hasRequestProvider()) 10076 composeReference(t, "ProcessResponse", "requestProvider", element.getRequestProvider(), -1); 10077 if (element.hasRequestOrganization()) 10078 composeReference(t, "ProcessResponse", "requestOrganization", element.getRequestOrganization(), -1); 10079 if (element.hasForm()) 10080 composeCodeableConcept(t, "ProcessResponse", "form", element.getForm(), -1); 10081 for (int i = 0; i < element.getProcessNote().size(); i++) 10082 composeProcessResponseProcessResponseProcessNoteComponent(t, "ProcessResponse", "processNote", element.getProcessNote().get(i), i); 10083 for (int i = 0; i < element.getError().size(); i++) 10084 composeCodeableConcept(t, "ProcessResponse", "error", element.getError().get(i), i); 10085 for (int i = 0; i < element.getCommunicationRequest().size(); i++) 10086 composeReference(t, "ProcessResponse", "communicationRequest", element.getCommunicationRequest().get(i), i); 10087 } 10088 10089 protected void composeProcessResponseProcessResponseProcessNoteComponent(Complex parent, String parentType, String name, ProcessResponse.ProcessResponseProcessNoteComponent element, int index) { 10090 if (element == null) 10091 return; 10092 Complex t; 10093 if (Utilities.noString(parentType)) 10094 t = parent; 10095 else { 10096 t = parent.predicate("fhir:"+parentType+'.'+name); 10097 } 10098 composeBackboneElement(t, "processNote", name, element, index); 10099 if (element.hasType()) 10100 composeCodeableConcept(t, "ProcessResponse", "type", element.getType(), -1); 10101 if (element.hasTextElement()) 10102 composeString(t, "ProcessResponse", "text", element.getTextElement(), -1); 10103 } 10104 10105 protected void composeProvenance(Complex parent, String parentType, String name, Provenance element, int index) { 10106 if (element == null) 10107 return; 10108 Complex t; 10109 if (Utilities.noString(parentType)) 10110 t = parent; 10111 else { 10112 t = parent.predicate("fhir:"+parentType+'.'+name); 10113 } 10114 composeDomainResource(t, "Provenance", name, element, index); 10115 for (int i = 0; i < element.getTarget().size(); i++) 10116 composeReference(t, "Provenance", "target", element.getTarget().get(i), i); 10117 if (element.hasPeriod()) 10118 composePeriod(t, "Provenance", "period", element.getPeriod(), -1); 10119 if (element.hasRecordedElement()) 10120 composeInstant(t, "Provenance", "recorded", element.getRecordedElement(), -1); 10121 for (int i = 0; i < element.getPolicy().size(); i++) 10122 composeUri(t, "Provenance", "policy", element.getPolicy().get(i), i); 10123 if (element.hasLocation()) 10124 composeReference(t, "Provenance", "location", element.getLocation(), -1); 10125 for (int i = 0; i < element.getReason().size(); i++) 10126 composeCoding(t, "Provenance", "reason", element.getReason().get(i), i); 10127 if (element.hasActivity()) 10128 composeCoding(t, "Provenance", "activity", element.getActivity(), -1); 10129 for (int i = 0; i < element.getAgent().size(); i++) 10130 composeProvenanceProvenanceAgentComponent(t, "Provenance", "agent", element.getAgent().get(i), i); 10131 for (int i = 0; i < element.getEntity().size(); i++) 10132 composeProvenanceProvenanceEntityComponent(t, "Provenance", "entity", element.getEntity().get(i), i); 10133 for (int i = 0; i < element.getSignature().size(); i++) 10134 composeSignature(t, "Provenance", "signature", element.getSignature().get(i), i); 10135 } 10136 10137 protected void composeProvenanceProvenanceAgentComponent(Complex parent, String parentType, String name, Provenance.ProvenanceAgentComponent element, int index) { 10138 if (element == null) 10139 return; 10140 Complex t; 10141 if (Utilities.noString(parentType)) 10142 t = parent; 10143 else { 10144 t = parent.predicate("fhir:"+parentType+'.'+name); 10145 } 10146 composeBackboneElement(t, "agent", name, element, index); 10147 for (int i = 0; i < element.getRole().size(); i++) 10148 composeCodeableConcept(t, "Provenance", "role", element.getRole().get(i), i); 10149 if (element.hasWho()) 10150 composeType(t, "Provenance", "who", element.getWho(), -1); 10151 if (element.hasOnBehalfOf()) 10152 composeType(t, "Provenance", "onBehalfOf", element.getOnBehalfOf(), -1); 10153 if (element.hasRelatedAgentType()) 10154 composeCodeableConcept(t, "Provenance", "relatedAgentType", element.getRelatedAgentType(), -1); 10155 } 10156 10157 protected void composeProvenanceProvenanceEntityComponent(Complex parent, String parentType, String name, Provenance.ProvenanceEntityComponent 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, "entity", name, element, index); 10167 if (element.hasRoleElement()) 10168 composeEnum(t, "Provenance", "role", element.getRoleElement(), -1); 10169 if (element.hasWhat()) 10170 composeType(t, "Provenance", "what", element.getWhat(), -1); 10171 for (int i = 0; i < element.getAgent().size(); i++) 10172 composeProvenanceProvenanceAgentComponent(t, "Provenance", "agent", element.getAgent().get(i), i); 10173 } 10174 10175 protected void composeQuestionnaire(Complex parent, String parentType, String name, Questionnaire element, int index) { 10176 if (element == null) 10177 return; 10178 Complex t; 10179 if (Utilities.noString(parentType)) 10180 t = parent; 10181 else { 10182 t = parent.predicate("fhir:"+parentType+'.'+name); 10183 } 10184 composeDomainResource(t, "Questionnaire", name, element, index); 10185 if (element.hasUrlElement()) 10186 composeUri(t, "Questionnaire", "url", element.getUrlElement(), -1); 10187 for (int i = 0; i < element.getIdentifier().size(); i++) 10188 composeIdentifier(t, "Questionnaire", "identifier", element.getIdentifier().get(i), i); 10189 if (element.hasVersionElement()) 10190 composeString(t, "Questionnaire", "version", element.getVersionElement(), -1); 10191 if (element.hasNameElement()) 10192 composeString(t, "Questionnaire", "name", element.getNameElement(), -1); 10193 if (element.hasTitleElement()) 10194 composeString(t, "Questionnaire", "title", element.getTitleElement(), -1); 10195 if (element.hasStatusElement()) 10196 composeEnum(t, "Questionnaire", "status", element.getStatusElement(), -1); 10197 if (element.hasExperimentalElement()) 10198 composeBoolean(t, "Questionnaire", "experimental", element.getExperimentalElement(), -1); 10199 if (element.hasDateElement()) 10200 composeDateTime(t, "Questionnaire", "date", element.getDateElement(), -1); 10201 if (element.hasPublisherElement()) 10202 composeString(t, "Questionnaire", "publisher", element.getPublisherElement(), -1); 10203 if (element.hasDescriptionElement()) 10204 composeMarkdown(t, "Questionnaire", "description", element.getDescriptionElement(), -1); 10205 if (element.hasPurposeElement()) 10206 composeMarkdown(t, "Questionnaire", "purpose", element.getPurposeElement(), -1); 10207 if (element.hasApprovalDateElement()) 10208 composeDate(t, "Questionnaire", "approvalDate", element.getApprovalDateElement(), -1); 10209 if (element.hasLastReviewDateElement()) 10210 composeDate(t, "Questionnaire", "lastReviewDate", element.getLastReviewDateElement(), -1); 10211 if (element.hasEffectivePeriod()) 10212 composePeriod(t, "Questionnaire", "effectivePeriod", element.getEffectivePeriod(), -1); 10213 for (int i = 0; i < element.getUseContext().size(); i++) 10214 composeUsageContext(t, "Questionnaire", "useContext", element.getUseContext().get(i), i); 10215 for (int i = 0; i < element.getJurisdiction().size(); i++) 10216 composeCodeableConcept(t, "Questionnaire", "jurisdiction", element.getJurisdiction().get(i), i); 10217 for (int i = 0; i < element.getContact().size(); i++) 10218 composeContactDetail(t, "Questionnaire", "contact", element.getContact().get(i), i); 10219 if (element.hasCopyrightElement()) 10220 composeMarkdown(t, "Questionnaire", "copyright", element.getCopyrightElement(), -1); 10221 for (int i = 0; i < element.getCode().size(); i++) 10222 composeCoding(t, "Questionnaire", "code", element.getCode().get(i), i); 10223 for (int i = 0; i < element.getSubjectType().size(); i++) 10224 composeCode(t, "Questionnaire", "subjectType", element.getSubjectType().get(i), i); 10225 for (int i = 0; i < element.getItem().size(); i++) 10226 composeQuestionnaireQuestionnaireItemComponent(t, "Questionnaire", "item", element.getItem().get(i), i); 10227 } 10228 10229 protected void composeQuestionnaireQuestionnaireItemComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemComponent element, int index) { 10230 if (element == null) 10231 return; 10232 Complex t; 10233 if (Utilities.noString(parentType)) 10234 t = parent; 10235 else { 10236 t = parent.predicate("fhir:"+parentType+'.'+name); 10237 } 10238 composeBackboneElement(t, "item", name, element, index); 10239 if (element.hasLinkIdElement()) 10240 composeString(t, "Questionnaire", "linkId", element.getLinkIdElement(), -1); 10241 if (element.hasDefinitionElement()) 10242 composeUri(t, "Questionnaire", "definition", element.getDefinitionElement(), -1); 10243 for (int i = 0; i < element.getCode().size(); i++) 10244 composeCoding(t, "Questionnaire", "code", element.getCode().get(i), i); 10245 if (element.hasPrefixElement()) 10246 composeString(t, "Questionnaire", "prefix", element.getPrefixElement(), -1); 10247 if (element.hasTextElement()) 10248 composeString(t, "Questionnaire", "text", element.getTextElement(), -1); 10249 if (element.hasTypeElement()) 10250 composeEnum(t, "Questionnaire", "type", element.getTypeElement(), -1); 10251 for (int i = 0; i < element.getEnableWhen().size(); i++) 10252 composeQuestionnaireQuestionnaireItemEnableWhenComponent(t, "Questionnaire", "enableWhen", element.getEnableWhen().get(i), i); 10253 if (element.hasRequiredElement()) 10254 composeBoolean(t, "Questionnaire", "required", element.getRequiredElement(), -1); 10255 if (element.hasRepeatsElement()) 10256 composeBoolean(t, "Questionnaire", "repeats", element.getRepeatsElement(), -1); 10257 if (element.hasReadOnlyElement()) 10258 composeBoolean(t, "Questionnaire", "readOnly", element.getReadOnlyElement(), -1); 10259 if (element.hasMaxLengthElement()) 10260 composeInteger(t, "Questionnaire", "maxLength", element.getMaxLengthElement(), -1); 10261 if (element.hasOptions()) 10262 composeReference(t, "Questionnaire", "options", element.getOptions(), -1); 10263 for (int i = 0; i < element.getOption().size(); i++) 10264 composeQuestionnaireQuestionnaireItemOptionComponent(t, "Questionnaire", "option", element.getOption().get(i), i); 10265 if (element.hasInitial()) 10266 composeType(t, "Questionnaire", "initial", element.getInitial(), -1); 10267 for (int i = 0; i < element.getItem().size(); i++) 10268 composeQuestionnaireQuestionnaireItemComponent(t, "Questionnaire", "item", element.getItem().get(i), i); 10269 } 10270 10271 protected void composeQuestionnaireQuestionnaireItemEnableWhenComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemEnableWhenComponent element, int index) { 10272 if (element == null) 10273 return; 10274 Complex t; 10275 if (Utilities.noString(parentType)) 10276 t = parent; 10277 else { 10278 t = parent.predicate("fhir:"+parentType+'.'+name); 10279 } 10280 composeBackboneElement(t, "enableWhen", name, element, index); 10281 if (element.hasQuestionElement()) 10282 composeString(t, "Questionnaire", "question", element.getQuestionElement(), -1); 10283 if (element.hasHasAnswerElement()) 10284 composeBoolean(t, "Questionnaire", "hasAnswer", element.getHasAnswerElement(), -1); 10285 if (element.hasAnswer()) 10286 composeType(t, "Questionnaire", "answer", element.getAnswer(), -1); 10287 } 10288 10289 protected void composeQuestionnaireQuestionnaireItemOptionComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemOptionComponent element, int index) { 10290 if (element == null) 10291 return; 10292 Complex t; 10293 if (Utilities.noString(parentType)) 10294 t = parent; 10295 else { 10296 t = parent.predicate("fhir:"+parentType+'.'+name); 10297 } 10298 composeBackboneElement(t, "option", name, element, index); 10299 if (element.hasValue()) 10300 composeType(t, "Questionnaire", "value", element.getValue(), -1); 10301 } 10302 10303 protected void composeQuestionnaireResponse(Complex parent, String parentType, String name, QuestionnaireResponse element, int index) { 10304 if (element == null) 10305 return; 10306 Complex t; 10307 if (Utilities.noString(parentType)) 10308 t = parent; 10309 else { 10310 t = parent.predicate("fhir:"+parentType+'.'+name); 10311 } 10312 composeDomainResource(t, "QuestionnaireResponse", name, element, index); 10313 if (element.hasIdentifier()) 10314 composeIdentifier(t, "QuestionnaireResponse", "identifier", element.getIdentifier(), -1); 10315 for (int i = 0; i < element.getBasedOn().size(); i++) 10316 composeReference(t, "QuestionnaireResponse", "basedOn", element.getBasedOn().get(i), i); 10317 for (int i = 0; i < element.getParent().size(); i++) 10318 composeReference(t, "QuestionnaireResponse", "parent", element.getParent().get(i), i); 10319 if (element.hasQuestionnaire()) 10320 composeReference(t, "QuestionnaireResponse", "questionnaire", element.getQuestionnaire(), -1); 10321 if (element.hasStatusElement()) 10322 composeEnum(t, "QuestionnaireResponse", "status", element.getStatusElement(), -1); 10323 if (element.hasSubject()) 10324 composeReference(t, "QuestionnaireResponse", "subject", element.getSubject(), -1); 10325 if (element.hasContext()) 10326 composeReference(t, "QuestionnaireResponse", "context", element.getContext(), -1); 10327 if (element.hasAuthoredElement()) 10328 composeDateTime(t, "QuestionnaireResponse", "authored", element.getAuthoredElement(), -1); 10329 if (element.hasAuthor()) 10330 composeReference(t, "QuestionnaireResponse", "author", element.getAuthor(), -1); 10331 if (element.hasSource()) 10332 composeReference(t, "QuestionnaireResponse", "source", element.getSource(), -1); 10333 for (int i = 0; i < element.getItem().size(); i++) 10334 composeQuestionnaireResponseQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i); 10335 } 10336 10337 protected void composeQuestionnaireResponseQuestionnaireResponseItemComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemComponent element, int index) { 10338 if (element == null) 10339 return; 10340 Complex t; 10341 if (Utilities.noString(parentType)) 10342 t = parent; 10343 else { 10344 t = parent.predicate("fhir:"+parentType+'.'+name); 10345 } 10346 composeBackboneElement(t, "item", name, element, index); 10347 if (element.hasLinkIdElement()) 10348 composeString(t, "QuestionnaireResponse", "linkId", element.getLinkIdElement(), -1); 10349 if (element.hasDefinitionElement()) 10350 composeUri(t, "QuestionnaireResponse", "definition", element.getDefinitionElement(), -1); 10351 if (element.hasTextElement()) 10352 composeString(t, "QuestionnaireResponse", "text", element.getTextElement(), -1); 10353 if (element.hasSubject()) 10354 composeReference(t, "QuestionnaireResponse", "subject", element.getSubject(), -1); 10355 for (int i = 0; i < element.getAnswer().size(); i++) 10356 composeQuestionnaireResponseQuestionnaireResponseItemAnswerComponent(t, "QuestionnaireResponse", "answer", element.getAnswer().get(i), i); 10357 for (int i = 0; i < element.getItem().size(); i++) 10358 composeQuestionnaireResponseQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i); 10359 } 10360 10361 protected void composeQuestionnaireResponseQuestionnaireResponseItemAnswerComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent element, int index) { 10362 if (element == null) 10363 return; 10364 Complex t; 10365 if (Utilities.noString(parentType)) 10366 t = parent; 10367 else { 10368 t = parent.predicate("fhir:"+parentType+'.'+name); 10369 } 10370 composeBackboneElement(t, "answer", name, element, index); 10371 if (element.hasValue()) 10372 composeType(t, "QuestionnaireResponse", "value", element.getValue(), -1); 10373 for (int i = 0; i < element.getItem().size(); i++) 10374 composeQuestionnaireResponseQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i); 10375 } 10376 10377 protected void composeReferralRequest(Complex parent, String parentType, String name, ReferralRequest element, int index) { 10378 if (element == null) 10379 return; 10380 Complex t; 10381 if (Utilities.noString(parentType)) 10382 t = parent; 10383 else { 10384 t = parent.predicate("fhir:"+parentType+'.'+name); 10385 } 10386 composeDomainResource(t, "ReferralRequest", name, element, index); 10387 for (int i = 0; i < element.getIdentifier().size(); i++) 10388 composeIdentifier(t, "ReferralRequest", "identifier", element.getIdentifier().get(i), i); 10389 for (int i = 0; i < element.getDefinition().size(); i++) 10390 composeReference(t, "ReferralRequest", "definition", element.getDefinition().get(i), i); 10391 for (int i = 0; i < element.getBasedOn().size(); i++) 10392 composeReference(t, "ReferralRequest", "basedOn", element.getBasedOn().get(i), i); 10393 for (int i = 0; i < element.getReplaces().size(); i++) 10394 composeReference(t, "ReferralRequest", "replaces", element.getReplaces().get(i), i); 10395 if (element.hasGroupIdentifier()) 10396 composeIdentifier(t, "ReferralRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 10397 if (element.hasStatusElement()) 10398 composeEnum(t, "ReferralRequest", "status", element.getStatusElement(), -1); 10399 if (element.hasIntentElement()) 10400 composeEnum(t, "ReferralRequest", "intent", element.getIntentElement(), -1); 10401 if (element.hasType()) 10402 composeCodeableConcept(t, "ReferralRequest", "type", element.getType(), -1); 10403 if (element.hasPriorityElement()) 10404 composeEnum(t, "ReferralRequest", "priority", element.getPriorityElement(), -1); 10405 for (int i = 0; i < element.getServiceRequested().size(); i++) 10406 composeCodeableConcept(t, "ReferralRequest", "serviceRequested", element.getServiceRequested().get(i), i); 10407 if (element.hasSubject()) 10408 composeReference(t, "ReferralRequest", "subject", element.getSubject(), -1); 10409 if (element.hasContext()) 10410 composeReference(t, "ReferralRequest", "context", element.getContext(), -1); 10411 if (element.hasOccurrence()) 10412 composeType(t, "ReferralRequest", "occurrence", element.getOccurrence(), -1); 10413 if (element.hasAuthoredOnElement()) 10414 composeDateTime(t, "ReferralRequest", "authoredOn", element.getAuthoredOnElement(), -1); 10415 if (element.hasRequester()) 10416 composeReferralRequestReferralRequestRequesterComponent(t, "ReferralRequest", "requester", element.getRequester(), -1); 10417 if (element.hasSpecialty()) 10418 composeCodeableConcept(t, "ReferralRequest", "specialty", element.getSpecialty(), -1); 10419 for (int i = 0; i < element.getRecipient().size(); i++) 10420 composeReference(t, "ReferralRequest", "recipient", element.getRecipient().get(i), i); 10421 for (int i = 0; i < element.getReasonCode().size(); i++) 10422 composeCodeableConcept(t, "ReferralRequest", "reasonCode", element.getReasonCode().get(i), i); 10423 for (int i = 0; i < element.getReasonReference().size(); i++) 10424 composeReference(t, "ReferralRequest", "reasonReference", element.getReasonReference().get(i), i); 10425 if (element.hasDescriptionElement()) 10426 composeString(t, "ReferralRequest", "description", element.getDescriptionElement(), -1); 10427 for (int i = 0; i < element.getSupportingInfo().size(); i++) 10428 composeReference(t, "ReferralRequest", "supportingInfo", element.getSupportingInfo().get(i), i); 10429 for (int i = 0; i < element.getNote().size(); i++) 10430 composeAnnotation(t, "ReferralRequest", "note", element.getNote().get(i), i); 10431 for (int i = 0; i < element.getRelevantHistory().size(); i++) 10432 composeReference(t, "ReferralRequest", "relevantHistory", element.getRelevantHistory().get(i), i); 10433 } 10434 10435 protected void composeReferralRequestReferralRequestRequesterComponent(Complex parent, String parentType, String name, ReferralRequest.ReferralRequestRequesterComponent element, int index) { 10436 if (element == null) 10437 return; 10438 Complex t; 10439 if (Utilities.noString(parentType)) 10440 t = parent; 10441 else { 10442 t = parent.predicate("fhir:"+parentType+'.'+name); 10443 } 10444 composeBackboneElement(t, "requester", name, element, index); 10445 if (element.hasAgent()) 10446 composeReference(t, "ReferralRequest", "agent", element.getAgent(), -1); 10447 if (element.hasOnBehalfOf()) 10448 composeReference(t, "ReferralRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 10449 } 10450 10451 protected void composeRelatedPerson(Complex parent, String parentType, String name, RelatedPerson element, int index) { 10452 if (element == null) 10453 return; 10454 Complex t; 10455 if (Utilities.noString(parentType)) 10456 t = parent; 10457 else { 10458 t = parent.predicate("fhir:"+parentType+'.'+name); 10459 } 10460 composeDomainResource(t, "RelatedPerson", name, element, index); 10461 for (int i = 0; i < element.getIdentifier().size(); i++) 10462 composeIdentifier(t, "RelatedPerson", "identifier", element.getIdentifier().get(i), i); 10463 if (element.hasActiveElement()) 10464 composeBoolean(t, "RelatedPerson", "active", element.getActiveElement(), -1); 10465 if (element.hasPatient()) 10466 composeReference(t, "RelatedPerson", "patient", element.getPatient(), -1); 10467 if (element.hasRelationship()) 10468 composeCodeableConcept(t, "RelatedPerson", "relationship", element.getRelationship(), -1); 10469 for (int i = 0; i < element.getName().size(); i++) 10470 composeHumanName(t, "RelatedPerson", "name", element.getName().get(i), i); 10471 for (int i = 0; i < element.getTelecom().size(); i++) 10472 composeContactPoint(t, "RelatedPerson", "telecom", element.getTelecom().get(i), i); 10473 if (element.hasGenderElement()) 10474 composeEnum(t, "RelatedPerson", "gender", element.getGenderElement(), -1); 10475 if (element.hasBirthDateElement()) 10476 composeDate(t, "RelatedPerson", "birthDate", element.getBirthDateElement(), -1); 10477 for (int i = 0; i < element.getAddress().size(); i++) 10478 composeAddress(t, "RelatedPerson", "address", element.getAddress().get(i), i); 10479 for (int i = 0; i < element.getPhoto().size(); i++) 10480 composeAttachment(t, "RelatedPerson", "photo", element.getPhoto().get(i), i); 10481 if (element.hasPeriod()) 10482 composePeriod(t, "RelatedPerson", "period", element.getPeriod(), -1); 10483 } 10484 10485 protected void composeRequestGroup(Complex parent, String parentType, String name, RequestGroup element, int index) { 10486 if (element == null) 10487 return; 10488 Complex t; 10489 if (Utilities.noString(parentType)) 10490 t = parent; 10491 else { 10492 t = parent.predicate("fhir:"+parentType+'.'+name); 10493 } 10494 composeDomainResource(t, "RequestGroup", name, element, index); 10495 for (int i = 0; i < element.getIdentifier().size(); i++) 10496 composeIdentifier(t, "RequestGroup", "identifier", element.getIdentifier().get(i), i); 10497 for (int i = 0; i < element.getDefinition().size(); i++) 10498 composeReference(t, "RequestGroup", "definition", element.getDefinition().get(i), i); 10499 for (int i = 0; i < element.getBasedOn().size(); i++) 10500 composeReference(t, "RequestGroup", "basedOn", element.getBasedOn().get(i), i); 10501 for (int i = 0; i < element.getReplaces().size(); i++) 10502 composeReference(t, "RequestGroup", "replaces", element.getReplaces().get(i), i); 10503 if (element.hasGroupIdentifier()) 10504 composeIdentifier(t, "RequestGroup", "groupIdentifier", element.getGroupIdentifier(), -1); 10505 if (element.hasStatusElement()) 10506 composeEnum(t, "RequestGroup", "status", element.getStatusElement(), -1); 10507 if (element.hasIntentElement()) 10508 composeEnum(t, "RequestGroup", "intent", element.getIntentElement(), -1); 10509 if (element.hasPriorityElement()) 10510 composeEnum(t, "RequestGroup", "priority", element.getPriorityElement(), -1); 10511 if (element.hasSubject()) 10512 composeReference(t, "RequestGroup", "subject", element.getSubject(), -1); 10513 if (element.hasContext()) 10514 composeReference(t, "RequestGroup", "context", element.getContext(), -1); 10515 if (element.hasAuthoredOnElement()) 10516 composeDateTime(t, "RequestGroup", "authoredOn", element.getAuthoredOnElement(), -1); 10517 if (element.hasAuthor()) 10518 composeReference(t, "RequestGroup", "author", element.getAuthor(), -1); 10519 if (element.hasReason()) 10520 composeType(t, "RequestGroup", "reason", element.getReason(), -1); 10521 for (int i = 0; i < element.getNote().size(); i++) 10522 composeAnnotation(t, "RequestGroup", "note", element.getNote().get(i), i); 10523 for (int i = 0; i < element.getAction().size(); i++) 10524 composeRequestGroupRequestGroupActionComponent(t, "RequestGroup", "action", element.getAction().get(i), i); 10525 } 10526 10527 protected void composeRequestGroupRequestGroupActionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionComponent element, int index) { 10528 if (element == null) 10529 return; 10530 Complex t; 10531 if (Utilities.noString(parentType)) 10532 t = parent; 10533 else { 10534 t = parent.predicate("fhir:"+parentType+'.'+name); 10535 } 10536 composeBackboneElement(t, "action", name, element, index); 10537 if (element.hasLabelElement()) 10538 composeString(t, "RequestGroup", "label", element.getLabelElement(), -1); 10539 if (element.hasTitleElement()) 10540 composeString(t, "RequestGroup", "title", element.getTitleElement(), -1); 10541 if (element.hasDescriptionElement()) 10542 composeString(t, "RequestGroup", "description", element.getDescriptionElement(), -1); 10543 if (element.hasTextEquivalentElement()) 10544 composeString(t, "RequestGroup", "textEquivalent", element.getTextEquivalentElement(), -1); 10545 for (int i = 0; i < element.getCode().size(); i++) 10546 composeCodeableConcept(t, "RequestGroup", "code", element.getCode().get(i), i); 10547 for (int i = 0; i < element.getDocumentation().size(); i++) 10548 composeRelatedArtifact(t, "RequestGroup", "documentation", element.getDocumentation().get(i), i); 10549 for (int i = 0; i < element.getCondition().size(); i++) 10550 composeRequestGroupRequestGroupActionConditionComponent(t, "RequestGroup", "condition", element.getCondition().get(i), i); 10551 for (int i = 0; i < element.getRelatedAction().size(); i++) 10552 composeRequestGroupRequestGroupActionRelatedActionComponent(t, "RequestGroup", "relatedAction", element.getRelatedAction().get(i), i); 10553 if (element.hasTiming()) 10554 composeType(t, "RequestGroup", "timing", element.getTiming(), -1); 10555 for (int i = 0; i < element.getParticipant().size(); i++) 10556 composeReference(t, "RequestGroup", "participant", element.getParticipant().get(i), i); 10557 if (element.hasType()) 10558 composeCoding(t, "RequestGroup", "type", element.getType(), -1); 10559 if (element.hasGroupingBehaviorElement()) 10560 composeEnum(t, "RequestGroup", "groupingBehavior", element.getGroupingBehaviorElement(), -1); 10561 if (element.hasSelectionBehaviorElement()) 10562 composeEnum(t, "RequestGroup", "selectionBehavior", element.getSelectionBehaviorElement(), -1); 10563 if (element.hasRequiredBehaviorElement()) 10564 composeEnum(t, "RequestGroup", "requiredBehavior", element.getRequiredBehaviorElement(), -1); 10565 if (element.hasPrecheckBehaviorElement()) 10566 composeEnum(t, "RequestGroup", "precheckBehavior", element.getPrecheckBehaviorElement(), -1); 10567 if (element.hasCardinalityBehaviorElement()) 10568 composeEnum(t, "RequestGroup", "cardinalityBehavior", element.getCardinalityBehaviorElement(), -1); 10569 if (element.hasResource()) 10570 composeReference(t, "RequestGroup", "resource", element.getResource(), -1); 10571 for (int i = 0; i < element.getAction().size(); i++) 10572 composeRequestGroupRequestGroupActionComponent(t, "RequestGroup", "action", element.getAction().get(i), i); 10573 } 10574 10575 protected void composeRequestGroupRequestGroupActionConditionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionConditionComponent element, int index) { 10576 if (element == null) 10577 return; 10578 Complex t; 10579 if (Utilities.noString(parentType)) 10580 t = parent; 10581 else { 10582 t = parent.predicate("fhir:"+parentType+'.'+name); 10583 } 10584 composeBackboneElement(t, "condition", name, element, index); 10585 if (element.hasKindElement()) 10586 composeEnum(t, "RequestGroup", "kind", element.getKindElement(), -1); 10587 if (element.hasDescriptionElement()) 10588 composeString(t, "RequestGroup", "description", element.getDescriptionElement(), -1); 10589 if (element.hasLanguageElement()) 10590 composeString(t, "RequestGroup", "language", element.getLanguageElement(), -1); 10591 if (element.hasExpressionElement()) 10592 composeString(t, "RequestGroup", "expression", element.getExpressionElement(), -1); 10593 } 10594 10595 protected void composeRequestGroupRequestGroupActionRelatedActionComponent(Complex parent, String parentType, String name, RequestGroup.RequestGroupActionRelatedActionComponent 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, "relatedAction", name, element, index); 10605 if (element.hasActionIdElement()) 10606 composeId(t, "RequestGroup", "actionId", element.getActionIdElement(), -1); 10607 if (element.hasRelationshipElement()) 10608 composeEnum(t, "RequestGroup", "relationship", element.getRelationshipElement(), -1); 10609 if (element.hasOffset()) 10610 composeType(t, "RequestGroup", "offset", element.getOffset(), -1); 10611 } 10612 10613 protected void composeResearchStudy(Complex parent, String parentType, String name, ResearchStudy element, int index) { 10614 if (element == null) 10615 return; 10616 Complex t; 10617 if (Utilities.noString(parentType)) 10618 t = parent; 10619 else { 10620 t = parent.predicate("fhir:"+parentType+'.'+name); 10621 } 10622 composeDomainResource(t, "ResearchStudy", name, element, index); 10623 for (int i = 0; i < element.getIdentifier().size(); i++) 10624 composeIdentifier(t, "ResearchStudy", "identifier", element.getIdentifier().get(i), i); 10625 if (element.hasTitleElement()) 10626 composeString(t, "ResearchStudy", "title", element.getTitleElement(), -1); 10627 for (int i = 0; i < element.getProtocol().size(); i++) 10628 composeReference(t, "ResearchStudy", "protocol", element.getProtocol().get(i), i); 10629 for (int i = 0; i < element.getPartOf().size(); i++) 10630 composeReference(t, "ResearchStudy", "partOf", element.getPartOf().get(i), i); 10631 if (element.hasStatusElement()) 10632 composeEnum(t, "ResearchStudy", "status", element.getStatusElement(), -1); 10633 for (int i = 0; i < element.getCategory().size(); i++) 10634 composeCodeableConcept(t, "ResearchStudy", "category", element.getCategory().get(i), i); 10635 for (int i = 0; i < element.getFocus().size(); i++) 10636 composeCodeableConcept(t, "ResearchStudy", "focus", element.getFocus().get(i), i); 10637 for (int i = 0; i < element.getContact().size(); i++) 10638 composeContactDetail(t, "ResearchStudy", "contact", element.getContact().get(i), i); 10639 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 10640 composeRelatedArtifact(t, "ResearchStudy", "relatedArtifact", element.getRelatedArtifact().get(i), i); 10641 for (int i = 0; i < element.getKeyword().size(); i++) 10642 composeCodeableConcept(t, "ResearchStudy", "keyword", element.getKeyword().get(i), i); 10643 for (int i = 0; i < element.getJurisdiction().size(); i++) 10644 composeCodeableConcept(t, "ResearchStudy", "jurisdiction", element.getJurisdiction().get(i), i); 10645 if (element.hasDescriptionElement()) 10646 composeMarkdown(t, "ResearchStudy", "description", element.getDescriptionElement(), -1); 10647 for (int i = 0; i < element.getEnrollment().size(); i++) 10648 composeReference(t, "ResearchStudy", "enrollment", element.getEnrollment().get(i), i); 10649 if (element.hasPeriod()) 10650 composePeriod(t, "ResearchStudy", "period", element.getPeriod(), -1); 10651 if (element.hasSponsor()) 10652 composeReference(t, "ResearchStudy", "sponsor", element.getSponsor(), -1); 10653 if (element.hasPrincipalInvestigator()) 10654 composeReference(t, "ResearchStudy", "principalInvestigator", element.getPrincipalInvestigator(), -1); 10655 for (int i = 0; i < element.getSite().size(); i++) 10656 composeReference(t, "ResearchStudy", "site", element.getSite().get(i), i); 10657 if (element.hasReasonStopped()) 10658 composeCodeableConcept(t, "ResearchStudy", "reasonStopped", element.getReasonStopped(), -1); 10659 for (int i = 0; i < element.getNote().size(); i++) 10660 composeAnnotation(t, "ResearchStudy", "note", element.getNote().get(i), i); 10661 for (int i = 0; i < element.getArm().size(); i++) 10662 composeResearchStudyResearchStudyArmComponent(t, "ResearchStudy", "arm", element.getArm().get(i), i); 10663 } 10664 10665 protected void composeResearchStudyResearchStudyArmComponent(Complex parent, String parentType, String name, ResearchStudy.ResearchStudyArmComponent element, int index) { 10666 if (element == null) 10667 return; 10668 Complex t; 10669 if (Utilities.noString(parentType)) 10670 t = parent; 10671 else { 10672 t = parent.predicate("fhir:"+parentType+'.'+name); 10673 } 10674 composeBackboneElement(t, "arm", name, element, index); 10675 if (element.hasNameElement()) 10676 composeString(t, "ResearchStudy", "name", element.getNameElement(), -1); 10677 if (element.hasCode()) 10678 composeCodeableConcept(t, "ResearchStudy", "code", element.getCode(), -1); 10679 if (element.hasDescriptionElement()) 10680 composeString(t, "ResearchStudy", "description", element.getDescriptionElement(), -1); 10681 } 10682 10683 protected void composeResearchSubject(Complex parent, String parentType, String name, ResearchSubject element, int index) { 10684 if (element == null) 10685 return; 10686 Complex t; 10687 if (Utilities.noString(parentType)) 10688 t = parent; 10689 else { 10690 t = parent.predicate("fhir:"+parentType+'.'+name); 10691 } 10692 composeDomainResource(t, "ResearchSubject", name, element, index); 10693 if (element.hasIdentifier()) 10694 composeIdentifier(t, "ResearchSubject", "identifier", element.getIdentifier(), -1); 10695 if (element.hasStatusElement()) 10696 composeEnum(t, "ResearchSubject", "status", element.getStatusElement(), -1); 10697 if (element.hasPeriod()) 10698 composePeriod(t, "ResearchSubject", "period", element.getPeriod(), -1); 10699 if (element.hasStudy()) 10700 composeReference(t, "ResearchSubject", "study", element.getStudy(), -1); 10701 if (element.hasIndividual()) 10702 composeReference(t, "ResearchSubject", "individual", element.getIndividual(), -1); 10703 if (element.hasAssignedArmElement()) 10704 composeString(t, "ResearchSubject", "assignedArm", element.getAssignedArmElement(), -1); 10705 if (element.hasActualArmElement()) 10706 composeString(t, "ResearchSubject", "actualArm", element.getActualArmElement(), -1); 10707 if (element.hasConsent()) 10708 composeReference(t, "ResearchSubject", "consent", element.getConsent(), -1); 10709 } 10710 10711 protected void composeRiskAssessment(Complex parent, String parentType, String name, RiskAssessment element, int index) { 10712 if (element == null) 10713 return; 10714 Complex t; 10715 if (Utilities.noString(parentType)) 10716 t = parent; 10717 else { 10718 t = parent.predicate("fhir:"+parentType+'.'+name); 10719 } 10720 composeDomainResource(t, "RiskAssessment", name, element, index); 10721 if (element.hasIdentifier()) 10722 composeIdentifier(t, "RiskAssessment", "identifier", element.getIdentifier(), -1); 10723 if (element.hasBasedOn()) 10724 composeReference(t, "RiskAssessment", "basedOn", element.getBasedOn(), -1); 10725 if (element.hasParent()) 10726 composeReference(t, "RiskAssessment", "parent", element.getParent(), -1); 10727 if (element.hasStatusElement()) 10728 composeEnum(t, "RiskAssessment", "status", element.getStatusElement(), -1); 10729 if (element.hasMethod()) 10730 composeCodeableConcept(t, "RiskAssessment", "method", element.getMethod(), -1); 10731 if (element.hasCode()) 10732 composeCodeableConcept(t, "RiskAssessment", "code", element.getCode(), -1); 10733 if (element.hasSubject()) 10734 composeReference(t, "RiskAssessment", "subject", element.getSubject(), -1); 10735 if (element.hasContext()) 10736 composeReference(t, "RiskAssessment", "context", element.getContext(), -1); 10737 if (element.hasOccurrence()) 10738 composeType(t, "RiskAssessment", "occurrence", element.getOccurrence(), -1); 10739 if (element.hasCondition()) 10740 composeReference(t, "RiskAssessment", "condition", element.getCondition(), -1); 10741 if (element.hasPerformer()) 10742 composeReference(t, "RiskAssessment", "performer", element.getPerformer(), -1); 10743 if (element.hasReason()) 10744 composeType(t, "RiskAssessment", "reason", element.getReason(), -1); 10745 for (int i = 0; i < element.getBasis().size(); i++) 10746 composeReference(t, "RiskAssessment", "basis", element.getBasis().get(i), i); 10747 for (int i = 0; i < element.getPrediction().size(); i++) 10748 composeRiskAssessmentRiskAssessmentPredictionComponent(t, "RiskAssessment", "prediction", element.getPrediction().get(i), i); 10749 if (element.hasMitigationElement()) 10750 composeString(t, "RiskAssessment", "mitigation", element.getMitigationElement(), -1); 10751 if (element.hasCommentElement()) 10752 composeString(t, "RiskAssessment", "comment", element.getCommentElement(), -1); 10753 } 10754 10755 protected void composeRiskAssessmentRiskAssessmentPredictionComponent(Complex parent, String parentType, String name, RiskAssessment.RiskAssessmentPredictionComponent element, int index) { 10756 if (element == null) 10757 return; 10758 Complex t; 10759 if (Utilities.noString(parentType)) 10760 t = parent; 10761 else { 10762 t = parent.predicate("fhir:"+parentType+'.'+name); 10763 } 10764 composeBackboneElement(t, "prediction", name, element, index); 10765 if (element.hasOutcome()) 10766 composeCodeableConcept(t, "RiskAssessment", "outcome", element.getOutcome(), -1); 10767 if (element.hasProbability()) 10768 composeType(t, "RiskAssessment", "probability", element.getProbability(), -1); 10769 if (element.hasQualitativeRisk()) 10770 composeCodeableConcept(t, "RiskAssessment", "qualitativeRisk", element.getQualitativeRisk(), -1); 10771 if (element.hasRelativeRiskElement()) 10772 composeDecimal(t, "RiskAssessment", "relativeRisk", element.getRelativeRiskElement(), -1); 10773 if (element.hasWhen()) 10774 composeType(t, "RiskAssessment", "when", element.getWhen(), -1); 10775 if (element.hasRationaleElement()) 10776 composeString(t, "RiskAssessment", "rationale", element.getRationaleElement(), -1); 10777 } 10778 10779 protected void composeSchedule(Complex parent, String parentType, String name, Schedule element, int index) { 10780 if (element == null) 10781 return; 10782 Complex t; 10783 if (Utilities.noString(parentType)) 10784 t = parent; 10785 else { 10786 t = parent.predicate("fhir:"+parentType+'.'+name); 10787 } 10788 composeDomainResource(t, "Schedule", name, element, index); 10789 for (int i = 0; i < element.getIdentifier().size(); i++) 10790 composeIdentifier(t, "Schedule", "identifier", element.getIdentifier().get(i), i); 10791 if (element.hasActiveElement()) 10792 composeBoolean(t, "Schedule", "active", element.getActiveElement(), -1); 10793 if (element.hasServiceCategory()) 10794 composeCodeableConcept(t, "Schedule", "serviceCategory", element.getServiceCategory(), -1); 10795 for (int i = 0; i < element.getServiceType().size(); i++) 10796 composeCodeableConcept(t, "Schedule", "serviceType", element.getServiceType().get(i), i); 10797 for (int i = 0; i < element.getSpecialty().size(); i++) 10798 composeCodeableConcept(t, "Schedule", "specialty", element.getSpecialty().get(i), i); 10799 for (int i = 0; i < element.getActor().size(); i++) 10800 composeReference(t, "Schedule", "actor", element.getActor().get(i), i); 10801 if (element.hasPlanningHorizon()) 10802 composePeriod(t, "Schedule", "planningHorizon", element.getPlanningHorizon(), -1); 10803 if (element.hasCommentElement()) 10804 composeString(t, "Schedule", "comment", element.getCommentElement(), -1); 10805 } 10806 10807 protected void composeSearchParameter(Complex parent, String parentType, String name, SearchParameter element, int index) { 10808 if (element == null) 10809 return; 10810 Complex t; 10811 if (Utilities.noString(parentType)) 10812 t = parent; 10813 else { 10814 t = parent.predicate("fhir:"+parentType+'.'+name); 10815 } 10816 composeDomainResource(t, "SearchParameter", name, element, index); 10817 if (element.hasUrlElement()) 10818 composeUri(t, "SearchParameter", "url", element.getUrlElement(), -1); 10819 if (element.hasVersionElement()) 10820 composeString(t, "SearchParameter", "version", element.getVersionElement(), -1); 10821 if (element.hasNameElement()) 10822 composeString(t, "SearchParameter", "name", element.getNameElement(), -1); 10823 if (element.hasStatusElement()) 10824 composeEnum(t, "SearchParameter", "status", element.getStatusElement(), -1); 10825 if (element.hasExperimentalElement()) 10826 composeBoolean(t, "SearchParameter", "experimental", element.getExperimentalElement(), -1); 10827 if (element.hasDateElement()) 10828 composeDateTime(t, "SearchParameter", "date", element.getDateElement(), -1); 10829 if (element.hasPublisherElement()) 10830 composeString(t, "SearchParameter", "publisher", element.getPublisherElement(), -1); 10831 for (int i = 0; i < element.getContact().size(); i++) 10832 composeContactDetail(t, "SearchParameter", "contact", element.getContact().get(i), i); 10833 for (int i = 0; i < element.getUseContext().size(); i++) 10834 composeUsageContext(t, "SearchParameter", "useContext", element.getUseContext().get(i), i); 10835 for (int i = 0; i < element.getJurisdiction().size(); i++) 10836 composeCodeableConcept(t, "SearchParameter", "jurisdiction", element.getJurisdiction().get(i), i); 10837 if (element.hasPurposeElement()) 10838 composeMarkdown(t, "SearchParameter", "purpose", element.getPurposeElement(), -1); 10839 if (element.hasCodeElement()) 10840 composeCode(t, "SearchParameter", "code", element.getCodeElement(), -1); 10841 for (int i = 0; i < element.getBase().size(); i++) 10842 composeCode(t, "SearchParameter", "base", element.getBase().get(i), i); 10843 if (element.hasTypeElement()) 10844 composeEnum(t, "SearchParameter", "type", element.getTypeElement(), -1); 10845 if (element.hasDerivedFromElement()) 10846 composeUri(t, "SearchParameter", "derivedFrom", element.getDerivedFromElement(), -1); 10847 if (element.hasDescriptionElement()) 10848 composeMarkdown(t, "SearchParameter", "description", element.getDescriptionElement(), -1); 10849 if (element.hasExpressionElement()) 10850 composeString(t, "SearchParameter", "expression", element.getExpressionElement(), -1); 10851 if (element.hasXpathElement()) 10852 composeString(t, "SearchParameter", "xpath", element.getXpathElement(), -1); 10853 if (element.hasXpathUsageElement()) 10854 composeEnum(t, "SearchParameter", "xpathUsage", element.getXpathUsageElement(), -1); 10855 for (int i = 0; i < element.getTarget().size(); i++) 10856 composeCode(t, "SearchParameter", "target", element.getTarget().get(i), i); 10857 for (int i = 0; i < element.getComparator().size(); i++) 10858 composeEnum(t, "SearchParameter", "comparator", element.getComparator().get(i), i); 10859 for (int i = 0; i < element.getModifier().size(); i++) 10860 composeEnum(t, "SearchParameter", "modifier", element.getModifier().get(i), i); 10861 for (int i = 0; i < element.getChain().size(); i++) 10862 composeString(t, "SearchParameter", "chain", element.getChain().get(i), i); 10863 for (int i = 0; i < element.getComponent().size(); i++) 10864 composeSearchParameterSearchParameterComponentComponent(t, "SearchParameter", "component", element.getComponent().get(i), i); 10865 } 10866 10867 protected void composeSearchParameterSearchParameterComponentComponent(Complex parent, String parentType, String name, SearchParameter.SearchParameterComponentComponent element, int index) { 10868 if (element == null) 10869 return; 10870 Complex t; 10871 if (Utilities.noString(parentType)) 10872 t = parent; 10873 else { 10874 t = parent.predicate("fhir:"+parentType+'.'+name); 10875 } 10876 composeBackboneElement(t, "component", name, element, index); 10877 if (element.hasDefinition()) 10878 composeReference(t, "SearchParameter", "definition", element.getDefinition(), -1); 10879 if (element.hasExpressionElement()) 10880 composeString(t, "SearchParameter", "expression", element.getExpressionElement(), -1); 10881 } 10882 10883 protected void composeSequence(Complex parent, String parentType, String name, Sequence element, int index) { 10884 if (element == null) 10885 return; 10886 Complex t; 10887 if (Utilities.noString(parentType)) 10888 t = parent; 10889 else { 10890 t = parent.predicate("fhir:"+parentType+'.'+name); 10891 } 10892 composeDomainResource(t, "Sequence", name, element, index); 10893 for (int i = 0; i < element.getIdentifier().size(); i++) 10894 composeIdentifier(t, "Sequence", "identifier", element.getIdentifier().get(i), i); 10895 if (element.hasTypeElement()) 10896 composeEnum(t, "Sequence", "type", element.getTypeElement(), -1); 10897 if (element.hasCoordinateSystemElement()) 10898 composeInteger(t, "Sequence", "coordinateSystem", element.getCoordinateSystemElement(), -1); 10899 if (element.hasPatient()) 10900 composeReference(t, "Sequence", "patient", element.getPatient(), -1); 10901 if (element.hasSpecimen()) 10902 composeReference(t, "Sequence", "specimen", element.getSpecimen(), -1); 10903 if (element.hasDevice()) 10904 composeReference(t, "Sequence", "device", element.getDevice(), -1); 10905 if (element.hasPerformer()) 10906 composeReference(t, "Sequence", "performer", element.getPerformer(), -1); 10907 if (element.hasQuantity()) 10908 composeQuantity(t, "Sequence", "quantity", element.getQuantity(), -1); 10909 if (element.hasReferenceSeq()) 10910 composeSequenceSequenceReferenceSeqComponent(t, "Sequence", "referenceSeq", element.getReferenceSeq(), -1); 10911 for (int i = 0; i < element.getVariant().size(); i++) 10912 composeSequenceSequenceVariantComponent(t, "Sequence", "variant", element.getVariant().get(i), i); 10913 if (element.hasObservedSeqElement()) 10914 composeString(t, "Sequence", "observedSeq", element.getObservedSeqElement(), -1); 10915 for (int i = 0; i < element.getQuality().size(); i++) 10916 composeSequenceSequenceQualityComponent(t, "Sequence", "quality", element.getQuality().get(i), i); 10917 if (element.hasReadCoverageElement()) 10918 composeInteger(t, "Sequence", "readCoverage", element.getReadCoverageElement(), -1); 10919 for (int i = 0; i < element.getRepository().size(); i++) 10920 composeSequenceSequenceRepositoryComponent(t, "Sequence", "repository", element.getRepository().get(i), i); 10921 for (int i = 0; i < element.getPointer().size(); i++) 10922 composeReference(t, "Sequence", "pointer", element.getPointer().get(i), i); 10923 } 10924 10925 protected void composeSequenceSequenceReferenceSeqComponent(Complex parent, String parentType, String name, Sequence.SequenceReferenceSeqComponent element, int index) { 10926 if (element == null) 10927 return; 10928 Complex t; 10929 if (Utilities.noString(parentType)) 10930 t = parent; 10931 else { 10932 t = parent.predicate("fhir:"+parentType+'.'+name); 10933 } 10934 composeBackboneElement(t, "referenceSeq", name, element, index); 10935 if (element.hasChromosome()) 10936 composeCodeableConcept(t, "Sequence", "chromosome", element.getChromosome(), -1); 10937 if (element.hasGenomeBuildElement()) 10938 composeString(t, "Sequence", "genomeBuild", element.getGenomeBuildElement(), -1); 10939 if (element.hasReferenceSeqId()) 10940 composeCodeableConcept(t, "Sequence", "referenceSeqId", element.getReferenceSeqId(), -1); 10941 if (element.hasReferenceSeqPointer()) 10942 composeReference(t, "Sequence", "referenceSeqPointer", element.getReferenceSeqPointer(), -1); 10943 if (element.hasReferenceSeqStringElement()) 10944 composeString(t, "Sequence", "referenceSeqString", element.getReferenceSeqStringElement(), -1); 10945 if (element.hasStrandElement()) 10946 composeInteger(t, "Sequence", "strand", element.getStrandElement(), -1); 10947 if (element.hasWindowStartElement()) 10948 composeInteger(t, "Sequence", "windowStart", element.getWindowStartElement(), -1); 10949 if (element.hasWindowEndElement()) 10950 composeInteger(t, "Sequence", "windowEnd", element.getWindowEndElement(), -1); 10951 } 10952 10953 protected void composeSequenceSequenceVariantComponent(Complex parent, String parentType, String name, Sequence.SequenceVariantComponent element, int index) { 10954 if (element == null) 10955 return; 10956 Complex t; 10957 if (Utilities.noString(parentType)) 10958 t = parent; 10959 else { 10960 t = parent.predicate("fhir:"+parentType+'.'+name); 10961 } 10962 composeBackboneElement(t, "variant", name, element, index); 10963 if (element.hasStartElement()) 10964 composeInteger(t, "Sequence", "start", element.getStartElement(), -1); 10965 if (element.hasEndElement()) 10966 composeInteger(t, "Sequence", "end", element.getEndElement(), -1); 10967 if (element.hasObservedAlleleElement()) 10968 composeString(t, "Sequence", "observedAllele", element.getObservedAlleleElement(), -1); 10969 if (element.hasReferenceAlleleElement()) 10970 composeString(t, "Sequence", "referenceAllele", element.getReferenceAlleleElement(), -1); 10971 if (element.hasCigarElement()) 10972 composeString(t, "Sequence", "cigar", element.getCigarElement(), -1); 10973 if (element.hasVariantPointer()) 10974 composeReference(t, "Sequence", "variantPointer", element.getVariantPointer(), -1); 10975 } 10976 10977 protected void composeSequenceSequenceQualityComponent(Complex parent, String parentType, String name, Sequence.SequenceQualityComponent element, int index) { 10978 if (element == null) 10979 return; 10980 Complex t; 10981 if (Utilities.noString(parentType)) 10982 t = parent; 10983 else { 10984 t = parent.predicate("fhir:"+parentType+'.'+name); 10985 } 10986 composeBackboneElement(t, "quality", name, element, index); 10987 if (element.hasTypeElement()) 10988 composeEnum(t, "Sequence", "type", element.getTypeElement(), -1); 10989 if (element.hasStandardSequence()) 10990 composeCodeableConcept(t, "Sequence", "standardSequence", element.getStandardSequence(), -1); 10991 if (element.hasStartElement()) 10992 composeInteger(t, "Sequence", "start", element.getStartElement(), -1); 10993 if (element.hasEndElement()) 10994 composeInteger(t, "Sequence", "end", element.getEndElement(), -1); 10995 if (element.hasScore()) 10996 composeQuantity(t, "Sequence", "score", element.getScore(), -1); 10997 if (element.hasMethod()) 10998 composeCodeableConcept(t, "Sequence", "method", element.getMethod(), -1); 10999 if (element.hasTruthTPElement()) 11000 composeDecimal(t, "Sequence", "truthTP", element.getTruthTPElement(), -1); 11001 if (element.hasQueryTPElement()) 11002 composeDecimal(t, "Sequence", "queryTP", element.getQueryTPElement(), -1); 11003 if (element.hasTruthFNElement()) 11004 composeDecimal(t, "Sequence", "truthFN", element.getTruthFNElement(), -1); 11005 if (element.hasQueryFPElement()) 11006 composeDecimal(t, "Sequence", "queryFP", element.getQueryFPElement(), -1); 11007 if (element.hasGtFPElement()) 11008 composeDecimal(t, "Sequence", "gtFP", element.getGtFPElement(), -1); 11009 if (element.hasPrecisionElement()) 11010 composeDecimal(t, "Sequence", "precision", element.getPrecisionElement(), -1); 11011 if (element.hasRecallElement()) 11012 composeDecimal(t, "Sequence", "recall", element.getRecallElement(), -1); 11013 if (element.hasFScoreElement()) 11014 composeDecimal(t, "Sequence", "fScore", element.getFScoreElement(), -1); 11015 } 11016 11017 protected void composeSequenceSequenceRepositoryComponent(Complex parent, String parentType, String name, Sequence.SequenceRepositoryComponent element, int index) { 11018 if (element == null) 11019 return; 11020 Complex t; 11021 if (Utilities.noString(parentType)) 11022 t = parent; 11023 else { 11024 t = parent.predicate("fhir:"+parentType+'.'+name); 11025 } 11026 composeBackboneElement(t, "repository", name, element, index); 11027 if (element.hasTypeElement()) 11028 composeEnum(t, "Sequence", "type", element.getTypeElement(), -1); 11029 if (element.hasUrlElement()) 11030 composeUri(t, "Sequence", "url", element.getUrlElement(), -1); 11031 if (element.hasNameElement()) 11032 composeString(t, "Sequence", "name", element.getNameElement(), -1); 11033 if (element.hasDatasetIdElement()) 11034 composeString(t, "Sequence", "datasetId", element.getDatasetIdElement(), -1); 11035 if (element.hasVariantsetIdElement()) 11036 composeString(t, "Sequence", "variantsetId", element.getVariantsetIdElement(), -1); 11037 if (element.hasReadsetIdElement()) 11038 composeString(t, "Sequence", "readsetId", element.getReadsetIdElement(), -1); 11039 } 11040 11041 protected void composeServiceDefinition(Complex parent, String parentType, String name, ServiceDefinition element, int index) { 11042 if (element == null) 11043 return; 11044 Complex t; 11045 if (Utilities.noString(parentType)) 11046 t = parent; 11047 else { 11048 t = parent.predicate("fhir:"+parentType+'.'+name); 11049 } 11050 composeDomainResource(t, "ServiceDefinition", name, element, index); 11051 if (element.hasUrlElement()) 11052 composeUri(t, "ServiceDefinition", "url", element.getUrlElement(), -1); 11053 for (int i = 0; i < element.getIdentifier().size(); i++) 11054 composeIdentifier(t, "ServiceDefinition", "identifier", element.getIdentifier().get(i), i); 11055 if (element.hasVersionElement()) 11056 composeString(t, "ServiceDefinition", "version", element.getVersionElement(), -1); 11057 if (element.hasNameElement()) 11058 composeString(t, "ServiceDefinition", "name", element.getNameElement(), -1); 11059 if (element.hasTitleElement()) 11060 composeString(t, "ServiceDefinition", "title", element.getTitleElement(), -1); 11061 if (element.hasStatusElement()) 11062 composeEnum(t, "ServiceDefinition", "status", element.getStatusElement(), -1); 11063 if (element.hasExperimentalElement()) 11064 composeBoolean(t, "ServiceDefinition", "experimental", element.getExperimentalElement(), -1); 11065 if (element.hasDateElement()) 11066 composeDateTime(t, "ServiceDefinition", "date", element.getDateElement(), -1); 11067 if (element.hasPublisherElement()) 11068 composeString(t, "ServiceDefinition", "publisher", element.getPublisherElement(), -1); 11069 if (element.hasDescriptionElement()) 11070 composeMarkdown(t, "ServiceDefinition", "description", element.getDescriptionElement(), -1); 11071 if (element.hasPurposeElement()) 11072 composeMarkdown(t, "ServiceDefinition", "purpose", element.getPurposeElement(), -1); 11073 if (element.hasUsageElement()) 11074 composeString(t, "ServiceDefinition", "usage", element.getUsageElement(), -1); 11075 if (element.hasApprovalDateElement()) 11076 composeDate(t, "ServiceDefinition", "approvalDate", element.getApprovalDateElement(), -1); 11077 if (element.hasLastReviewDateElement()) 11078 composeDate(t, "ServiceDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 11079 if (element.hasEffectivePeriod()) 11080 composePeriod(t, "ServiceDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 11081 for (int i = 0; i < element.getUseContext().size(); i++) 11082 composeUsageContext(t, "ServiceDefinition", "useContext", element.getUseContext().get(i), i); 11083 for (int i = 0; i < element.getJurisdiction().size(); i++) 11084 composeCodeableConcept(t, "ServiceDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 11085 for (int i = 0; i < element.getTopic().size(); i++) 11086 composeCodeableConcept(t, "ServiceDefinition", "topic", element.getTopic().get(i), i); 11087 for (int i = 0; i < element.getContributor().size(); i++) 11088 composeContributor(t, "ServiceDefinition", "contributor", element.getContributor().get(i), i); 11089 for (int i = 0; i < element.getContact().size(); i++) 11090 composeContactDetail(t, "ServiceDefinition", "contact", element.getContact().get(i), i); 11091 if (element.hasCopyrightElement()) 11092 composeMarkdown(t, "ServiceDefinition", "copyright", element.getCopyrightElement(), -1); 11093 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 11094 composeRelatedArtifact(t, "ServiceDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 11095 for (int i = 0; i < element.getTrigger().size(); i++) 11096 composeTriggerDefinition(t, "ServiceDefinition", "trigger", element.getTrigger().get(i), i); 11097 for (int i = 0; i < element.getDataRequirement().size(); i++) 11098 composeDataRequirement(t, "ServiceDefinition", "dataRequirement", element.getDataRequirement().get(i), i); 11099 if (element.hasOperationDefinition()) 11100 composeReference(t, "ServiceDefinition", "operationDefinition", element.getOperationDefinition(), -1); 11101 } 11102 11103 protected void composeSlot(Complex parent, String parentType, String name, Slot element, int index) { 11104 if (element == null) 11105 return; 11106 Complex t; 11107 if (Utilities.noString(parentType)) 11108 t = parent; 11109 else { 11110 t = parent.predicate("fhir:"+parentType+'.'+name); 11111 } 11112 composeDomainResource(t, "Slot", name, element, index); 11113 for (int i = 0; i < element.getIdentifier().size(); i++) 11114 composeIdentifier(t, "Slot", "identifier", element.getIdentifier().get(i), i); 11115 if (element.hasServiceCategory()) 11116 composeCodeableConcept(t, "Slot", "serviceCategory", element.getServiceCategory(), -1); 11117 for (int i = 0; i < element.getServiceType().size(); i++) 11118 composeCodeableConcept(t, "Slot", "serviceType", element.getServiceType().get(i), i); 11119 for (int i = 0; i < element.getSpecialty().size(); i++) 11120 composeCodeableConcept(t, "Slot", "specialty", element.getSpecialty().get(i), i); 11121 if (element.hasAppointmentType()) 11122 composeCodeableConcept(t, "Slot", "appointmentType", element.getAppointmentType(), -1); 11123 if (element.hasSchedule()) 11124 composeReference(t, "Slot", "schedule", element.getSchedule(), -1); 11125 if (element.hasStatusElement()) 11126 composeEnum(t, "Slot", "status", element.getStatusElement(), -1); 11127 if (element.hasStartElement()) 11128 composeInstant(t, "Slot", "start", element.getStartElement(), -1); 11129 if (element.hasEndElement()) 11130 composeInstant(t, "Slot", "end", element.getEndElement(), -1); 11131 if (element.hasOverbookedElement()) 11132 composeBoolean(t, "Slot", "overbooked", element.getOverbookedElement(), -1); 11133 if (element.hasCommentElement()) 11134 composeString(t, "Slot", "comment", element.getCommentElement(), -1); 11135 } 11136 11137 protected void composeSpecimen(Complex parent, String parentType, String name, Specimen element, int index) { 11138 if (element == null) 11139 return; 11140 Complex t; 11141 if (Utilities.noString(parentType)) 11142 t = parent; 11143 else { 11144 t = parent.predicate("fhir:"+parentType+'.'+name); 11145 } 11146 composeDomainResource(t, "Specimen", name, element, index); 11147 for (int i = 0; i < element.getIdentifier().size(); i++) 11148 composeIdentifier(t, "Specimen", "identifier", element.getIdentifier().get(i), i); 11149 if (element.hasAccessionIdentifier()) 11150 composeIdentifier(t, "Specimen", "accessionIdentifier", element.getAccessionIdentifier(), -1); 11151 if (element.hasStatusElement()) 11152 composeEnum(t, "Specimen", "status", element.getStatusElement(), -1); 11153 if (element.hasType()) 11154 composeCodeableConcept(t, "Specimen", "type", element.getType(), -1); 11155 if (element.hasSubject()) 11156 composeReference(t, "Specimen", "subject", element.getSubject(), -1); 11157 if (element.hasReceivedTimeElement()) 11158 composeDateTime(t, "Specimen", "receivedTime", element.getReceivedTimeElement(), -1); 11159 for (int i = 0; i < element.getParent().size(); i++) 11160 composeReference(t, "Specimen", "parent", element.getParent().get(i), i); 11161 for (int i = 0; i < element.getRequest().size(); i++) 11162 composeReference(t, "Specimen", "request", element.getRequest().get(i), i); 11163 if (element.hasCollection()) 11164 composeSpecimenSpecimenCollectionComponent(t, "Specimen", "collection", element.getCollection(), -1); 11165 for (int i = 0; i < element.getProcessing().size(); i++) 11166 composeSpecimenSpecimenProcessingComponent(t, "Specimen", "processing", element.getProcessing().get(i), i); 11167 for (int i = 0; i < element.getContainer().size(); i++) 11168 composeSpecimenSpecimenContainerComponent(t, "Specimen", "container", element.getContainer().get(i), i); 11169 for (int i = 0; i < element.getNote().size(); i++) 11170 composeAnnotation(t, "Specimen", "note", element.getNote().get(i), i); 11171 } 11172 11173 protected void composeSpecimenSpecimenCollectionComponent(Complex parent, String parentType, String name, Specimen.SpecimenCollectionComponent element, int index) { 11174 if (element == null) 11175 return; 11176 Complex t; 11177 if (Utilities.noString(parentType)) 11178 t = parent; 11179 else { 11180 t = parent.predicate("fhir:"+parentType+'.'+name); 11181 } 11182 composeBackboneElement(t, "collection", name, element, index); 11183 if (element.hasCollector()) 11184 composeReference(t, "Specimen", "collector", element.getCollector(), -1); 11185 if (element.hasCollected()) 11186 composeType(t, "Specimen", "collected", element.getCollected(), -1); 11187 if (element.hasQuantity()) 11188 composeQuantity(t, "Specimen", "quantity", element.getQuantity(), -1); 11189 if (element.hasMethod()) 11190 composeCodeableConcept(t, "Specimen", "method", element.getMethod(), -1); 11191 if (element.hasBodySite()) 11192 composeCodeableConcept(t, "Specimen", "bodySite", element.getBodySite(), -1); 11193 } 11194 11195 protected void composeSpecimenSpecimenProcessingComponent(Complex parent, String parentType, String name, Specimen.SpecimenProcessingComponent element, int index) { 11196 if (element == null) 11197 return; 11198 Complex t; 11199 if (Utilities.noString(parentType)) 11200 t = parent; 11201 else { 11202 t = parent.predicate("fhir:"+parentType+'.'+name); 11203 } 11204 composeBackboneElement(t, "processing", name, element, index); 11205 if (element.hasDescriptionElement()) 11206 composeString(t, "Specimen", "description", element.getDescriptionElement(), -1); 11207 if (element.hasProcedure()) 11208 composeCodeableConcept(t, "Specimen", "procedure", element.getProcedure(), -1); 11209 for (int i = 0; i < element.getAdditive().size(); i++) 11210 composeReference(t, "Specimen", "additive", element.getAdditive().get(i), i); 11211 if (element.hasTime()) 11212 composeType(t, "Specimen", "time", element.getTime(), -1); 11213 } 11214 11215 protected void composeSpecimenSpecimenContainerComponent(Complex parent, String parentType, String name, Specimen.SpecimenContainerComponent 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, "container", name, element, index); 11225 for (int i = 0; i < element.getIdentifier().size(); i++) 11226 composeIdentifier(t, "Specimen", "identifier", element.getIdentifier().get(i), i); 11227 if (element.hasDescriptionElement()) 11228 composeString(t, "Specimen", "description", element.getDescriptionElement(), -1); 11229 if (element.hasType()) 11230 composeCodeableConcept(t, "Specimen", "type", element.getType(), -1); 11231 if (element.hasCapacity()) 11232 composeQuantity(t, "Specimen", "capacity", element.getCapacity(), -1); 11233 if (element.hasSpecimenQuantity()) 11234 composeQuantity(t, "Specimen", "specimenQuantity", element.getSpecimenQuantity(), -1); 11235 if (element.hasAdditive()) 11236 composeType(t, "Specimen", "additive", element.getAdditive(), -1); 11237 } 11238 11239 protected void composeStructureDefinition(Complex parent, String parentType, String name, StructureDefinition element, int index) { 11240 if (element == null) 11241 return; 11242 Complex t; 11243 if (Utilities.noString(parentType)) 11244 t = parent; 11245 else { 11246 t = parent.predicate("fhir:"+parentType+'.'+name); 11247 } 11248 composeDomainResource(t, "StructureDefinition", name, element, index); 11249 if (element.hasUrlElement()) 11250 composeUri(t, "StructureDefinition", "url", element.getUrlElement(), -1); 11251 for (int i = 0; i < element.getIdentifier().size(); i++) 11252 composeIdentifier(t, "StructureDefinition", "identifier", element.getIdentifier().get(i), i); 11253 if (element.hasVersionElement()) 11254 composeString(t, "StructureDefinition", "version", element.getVersionElement(), -1); 11255 if (element.hasNameElement()) 11256 composeString(t, "StructureDefinition", "name", element.getNameElement(), -1); 11257 if (element.hasTitleElement()) 11258 composeString(t, "StructureDefinition", "title", element.getTitleElement(), -1); 11259 if (element.hasStatusElement()) 11260 composeEnum(t, "StructureDefinition", "status", element.getStatusElement(), -1); 11261 if (element.hasExperimentalElement()) 11262 composeBoolean(t, "StructureDefinition", "experimental", element.getExperimentalElement(), -1); 11263 if (element.hasDateElement()) 11264 composeDateTime(t, "StructureDefinition", "date", element.getDateElement(), -1); 11265 if (element.hasPublisherElement()) 11266 composeString(t, "StructureDefinition", "publisher", element.getPublisherElement(), -1); 11267 for (int i = 0; i < element.getContact().size(); i++) 11268 composeContactDetail(t, "StructureDefinition", "contact", element.getContact().get(i), i); 11269 if (element.hasDescriptionElement()) 11270 composeMarkdown(t, "StructureDefinition", "description", element.getDescriptionElement(), -1); 11271 for (int i = 0; i < element.getUseContext().size(); i++) 11272 composeUsageContext(t, "StructureDefinition", "useContext", element.getUseContext().get(i), i); 11273 for (int i = 0; i < element.getJurisdiction().size(); i++) 11274 composeCodeableConcept(t, "StructureDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 11275 if (element.hasPurposeElement()) 11276 composeMarkdown(t, "StructureDefinition", "purpose", element.getPurposeElement(), -1); 11277 if (element.hasCopyrightElement()) 11278 composeMarkdown(t, "StructureDefinition", "copyright", element.getCopyrightElement(), -1); 11279 for (int i = 0; i < element.getKeyword().size(); i++) 11280 composeCoding(t, "StructureDefinition", "keyword", element.getKeyword().get(i), i); 11281 if (element.hasFhirVersionElement()) 11282 composeId(t, "StructureDefinition", "fhirVersion", element.getFhirVersionElement(), -1); 11283 for (int i = 0; i < element.getMapping().size(); i++) 11284 composeStructureDefinitionStructureDefinitionMappingComponent(t, "StructureDefinition", "mapping", element.getMapping().get(i), i); 11285 if (element.hasKindElement()) 11286 composeEnum(t, "StructureDefinition", "kind", element.getKindElement(), -1); 11287 if (element.hasAbstractElement()) 11288 composeBoolean(t, "StructureDefinition", "abstract", element.getAbstractElement(), -1); 11289 if (element.hasContextTypeElement()) 11290 composeEnum(t, "StructureDefinition", "contextType", element.getContextTypeElement(), -1); 11291 for (int i = 0; i < element.getContext().size(); i++) 11292 composeString(t, "StructureDefinition", "context", element.getContext().get(i), i); 11293 for (int i = 0; i < element.getContextInvariant().size(); i++) 11294 composeString(t, "StructureDefinition", "contextInvariant", element.getContextInvariant().get(i), i); 11295 if (element.hasTypeElement()) 11296 composeCode(t, "StructureDefinition", "type", element.getTypeElement(), -1); 11297 if (element.hasBaseDefinitionElement()) 11298 composeUri(t, "StructureDefinition", "baseDefinition", element.getBaseDefinitionElement(), -1); 11299 if (element.hasDerivationElement()) 11300 composeEnum(t, "StructureDefinition", "derivation", element.getDerivationElement(), -1); 11301 if (element.hasSnapshot()) 11302 composeStructureDefinitionStructureDefinitionSnapshotComponent(t, "StructureDefinition", "snapshot", element.getSnapshot(), -1); 11303 if (element.hasDifferential()) 11304 composeStructureDefinitionStructureDefinitionDifferentialComponent(t, "StructureDefinition", "differential", element.getDifferential(), -1); 11305 } 11306 11307 protected void composeStructureDefinitionStructureDefinitionMappingComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionMappingComponent element, int index) { 11308 if (element == null) 11309 return; 11310 Complex t; 11311 if (Utilities.noString(parentType)) 11312 t = parent; 11313 else { 11314 t = parent.predicate("fhir:"+parentType+'.'+name); 11315 } 11316 composeBackboneElement(t, "mapping", name, element, index); 11317 if (element.hasIdentityElement()) 11318 composeId(t, "StructureDefinition", "identity", element.getIdentityElement(), -1); 11319 if (element.hasUriElement()) 11320 composeUri(t, "StructureDefinition", "uri", element.getUriElement(), -1); 11321 if (element.hasNameElement()) 11322 composeString(t, "StructureDefinition", "name", element.getNameElement(), -1); 11323 if (element.hasCommentElement()) 11324 composeString(t, "StructureDefinition", "comment", element.getCommentElement(), -1); 11325 } 11326 11327 protected void composeStructureDefinitionStructureDefinitionSnapshotComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionSnapshotComponent 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, "snapshot", name, element, index); 11337 for (int i = 0; i < element.getElement().size(); i++) 11338 composeElementDefinition(t, "StructureDefinition", "element", element.getElement().get(i), i); 11339 } 11340 11341 protected void composeStructureDefinitionStructureDefinitionDifferentialComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionDifferentialComponent element, int index) { 11342 if (element == null) 11343 return; 11344 Complex t; 11345 if (Utilities.noString(parentType)) 11346 t = parent; 11347 else { 11348 t = parent.predicate("fhir:"+parentType+'.'+name); 11349 } 11350 composeBackboneElement(t, "differential", name, element, index); 11351 for (int i = 0; i < element.getElement().size(); i++) 11352 composeElementDefinition(t, "StructureDefinition", "element", element.getElement().get(i), i); 11353 } 11354 11355 protected void composeStructureMap(Complex parent, String parentType, String name, StructureMap element, int index) { 11356 if (element == null) 11357 return; 11358 Complex t; 11359 if (Utilities.noString(parentType)) 11360 t = parent; 11361 else { 11362 t = parent.predicate("fhir:"+parentType+'.'+name); 11363 } 11364 composeDomainResource(t, "StructureMap", name, element, index); 11365 if (element.hasUrlElement()) 11366 composeUri(t, "StructureMap", "url", element.getUrlElement(), -1); 11367 for (int i = 0; i < element.getIdentifier().size(); i++) 11368 composeIdentifier(t, "StructureMap", "identifier", element.getIdentifier().get(i), i); 11369 if (element.hasVersionElement()) 11370 composeString(t, "StructureMap", "version", element.getVersionElement(), -1); 11371 if (element.hasNameElement()) 11372 composeString(t, "StructureMap", "name", element.getNameElement(), -1); 11373 if (element.hasTitleElement()) 11374 composeString(t, "StructureMap", "title", element.getTitleElement(), -1); 11375 if (element.hasStatusElement()) 11376 composeEnum(t, "StructureMap", "status", element.getStatusElement(), -1); 11377 if (element.hasExperimentalElement()) 11378 composeBoolean(t, "StructureMap", "experimental", element.getExperimentalElement(), -1); 11379 if (element.hasDateElement()) 11380 composeDateTime(t, "StructureMap", "date", element.getDateElement(), -1); 11381 if (element.hasPublisherElement()) 11382 composeString(t, "StructureMap", "publisher", element.getPublisherElement(), -1); 11383 for (int i = 0; i < element.getContact().size(); i++) 11384 composeContactDetail(t, "StructureMap", "contact", element.getContact().get(i), i); 11385 if (element.hasDescriptionElement()) 11386 composeMarkdown(t, "StructureMap", "description", element.getDescriptionElement(), -1); 11387 for (int i = 0; i < element.getUseContext().size(); i++) 11388 composeUsageContext(t, "StructureMap", "useContext", element.getUseContext().get(i), i); 11389 for (int i = 0; i < element.getJurisdiction().size(); i++) 11390 composeCodeableConcept(t, "StructureMap", "jurisdiction", element.getJurisdiction().get(i), i); 11391 if (element.hasPurposeElement()) 11392 composeMarkdown(t, "StructureMap", "purpose", element.getPurposeElement(), -1); 11393 if (element.hasCopyrightElement()) 11394 composeMarkdown(t, "StructureMap", "copyright", element.getCopyrightElement(), -1); 11395 for (int i = 0; i < element.getStructure().size(); i++) 11396 composeStructureMapStructureMapStructureComponent(t, "StructureMap", "structure", element.getStructure().get(i), i); 11397 for (int i = 0; i < element.getImport().size(); i++) 11398 composeUri(t, "StructureMap", "import", element.getImport().get(i), i); 11399 for (int i = 0; i < element.getGroup().size(); i++) 11400 composeStructureMapStructureMapGroupComponent(t, "StructureMap", "group", element.getGroup().get(i), i); 11401 } 11402 11403 protected void composeStructureMapStructureMapStructureComponent(Complex parent, String parentType, String name, StructureMap.StructureMapStructureComponent element, int index) { 11404 if (element == null) 11405 return; 11406 Complex t; 11407 if (Utilities.noString(parentType)) 11408 t = parent; 11409 else { 11410 t = parent.predicate("fhir:"+parentType+'.'+name); 11411 } 11412 composeBackboneElement(t, "structure", name, element, index); 11413 if (element.hasUrlElement()) 11414 composeUri(t, "StructureMap", "url", element.getUrlElement(), -1); 11415 if (element.hasModeElement()) 11416 composeEnum(t, "StructureMap", "mode", element.getModeElement(), -1); 11417 if (element.hasAliasElement()) 11418 composeString(t, "StructureMap", "alias", element.getAliasElement(), -1); 11419 if (element.hasDocumentationElement()) 11420 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 11421 } 11422 11423 protected void composeStructureMapStructureMapGroupComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupComponent 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, "group", name, element, index); 11433 if (element.hasNameElement()) 11434 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 11435 if (element.hasExtendsElement()) 11436 composeId(t, "StructureMap", "extends", element.getExtendsElement(), -1); 11437 if (element.hasTypeModeElement()) 11438 composeEnum(t, "StructureMap", "typeMode", element.getTypeModeElement(), -1); 11439 if (element.hasDocumentationElement()) 11440 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 11441 for (int i = 0; i < element.getInput().size(); i++) 11442 composeStructureMapStructureMapGroupInputComponent(t, "StructureMap", "input", element.getInput().get(i), i); 11443 for (int i = 0; i < element.getRule().size(); i++) 11444 composeStructureMapStructureMapGroupRuleComponent(t, "StructureMap", "rule", element.getRule().get(i), i); 11445 } 11446 11447 protected void composeStructureMapStructureMapGroupInputComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupInputComponent element, int index) { 11448 if (element == null) 11449 return; 11450 Complex t; 11451 if (Utilities.noString(parentType)) 11452 t = parent; 11453 else { 11454 t = parent.predicate("fhir:"+parentType+'.'+name); 11455 } 11456 composeBackboneElement(t, "input", name, element, index); 11457 if (element.hasNameElement()) 11458 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 11459 if (element.hasTypeElement()) 11460 composeString(t, "StructureMap", "type", element.getTypeElement(), -1); 11461 if (element.hasModeElement()) 11462 composeEnum(t, "StructureMap", "mode", element.getModeElement(), -1); 11463 if (element.hasDocumentationElement()) 11464 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 11465 } 11466 11467 protected void composeStructureMapStructureMapGroupRuleComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleComponent 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, "rule", name, element, index); 11477 if (element.hasNameElement()) 11478 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 11479 for (int i = 0; i < element.getSource().size(); i++) 11480 composeStructureMapStructureMapGroupRuleSourceComponent(t, "StructureMap", "source", element.getSource().get(i), i); 11481 for (int i = 0; i < element.getTarget().size(); i++) 11482 composeStructureMapStructureMapGroupRuleTargetComponent(t, "StructureMap", "target", element.getTarget().get(i), i); 11483 for (int i = 0; i < element.getRule().size(); i++) 11484 composeStructureMapStructureMapGroupRuleComponent(t, "StructureMap", "rule", element.getRule().get(i), i); 11485 for (int i = 0; i < element.getDependent().size(); i++) 11486 composeStructureMapStructureMapGroupRuleDependentComponent(t, "StructureMap", "dependent", element.getDependent().get(i), i); 11487 if (element.hasDocumentationElement()) 11488 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 11489 } 11490 11491 protected void composeStructureMapStructureMapGroupRuleSourceComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleSourceComponent element, int index) { 11492 if (element == null) 11493 return; 11494 Complex t; 11495 if (Utilities.noString(parentType)) 11496 t = parent; 11497 else { 11498 t = parent.predicate("fhir:"+parentType+'.'+name); 11499 } 11500 composeBackboneElement(t, "source", name, element, index); 11501 if (element.hasContextElement()) 11502 composeId(t, "StructureMap", "context", element.getContextElement(), -1); 11503 if (element.hasMinElement()) 11504 composeInteger(t, "StructureMap", "min", element.getMinElement(), -1); 11505 if (element.hasMaxElement()) 11506 composeString(t, "StructureMap", "max", element.getMaxElement(), -1); 11507 if (element.hasTypeElement()) 11508 composeString(t, "StructureMap", "type", element.getTypeElement(), -1); 11509 if (element.hasDefaultValue()) 11510 composeType(t, "StructureMap", "defaultValue", element.getDefaultValue(), -1); 11511 if (element.hasElementElement()) 11512 composeString(t, "StructureMap", "element", element.getElementElement(), -1); 11513 if (element.hasListModeElement()) 11514 composeEnum(t, "StructureMap", "listMode", element.getListModeElement(), -1); 11515 if (element.hasVariableElement()) 11516 composeId(t, "StructureMap", "variable", element.getVariableElement(), -1); 11517 if (element.hasConditionElement()) 11518 composeString(t, "StructureMap", "condition", element.getConditionElement(), -1); 11519 if (element.hasCheckElement()) 11520 composeString(t, "StructureMap", "check", element.getCheckElement(), -1); 11521 } 11522 11523 protected void composeStructureMapStructureMapGroupRuleTargetComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetComponent element, int index) { 11524 if (element == null) 11525 return; 11526 Complex t; 11527 if (Utilities.noString(parentType)) 11528 t = parent; 11529 else { 11530 t = parent.predicate("fhir:"+parentType+'.'+name); 11531 } 11532 composeBackboneElement(t, "target", name, element, index); 11533 if (element.hasContextElement()) 11534 composeId(t, "StructureMap", "context", element.getContextElement(), -1); 11535 if (element.hasContextTypeElement()) 11536 composeEnum(t, "StructureMap", "contextType", element.getContextTypeElement(), -1); 11537 if (element.hasElementElement()) 11538 composeString(t, "StructureMap", "element", element.getElementElement(), -1); 11539 if (element.hasVariableElement()) 11540 composeId(t, "StructureMap", "variable", element.getVariableElement(), -1); 11541 for (int i = 0; i < element.getListMode().size(); i++) 11542 composeEnum(t, "StructureMap", "listMode", element.getListMode().get(i), i); 11543 if (element.hasListRuleIdElement()) 11544 composeId(t, "StructureMap", "listRuleId", element.getListRuleIdElement(), -1); 11545 if (element.hasTransformElement()) 11546 composeEnum(t, "StructureMap", "transform", element.getTransformElement(), -1); 11547 for (int i = 0; i < element.getParameter().size(); i++) 11548 composeStructureMapStructureMapGroupRuleTargetParameterComponent(t, "StructureMap", "parameter", element.getParameter().get(i), i); 11549 } 11550 11551 protected void composeStructureMapStructureMapGroupRuleTargetParameterComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetParameterComponent element, int index) { 11552 if (element == null) 11553 return; 11554 Complex t; 11555 if (Utilities.noString(parentType)) 11556 t = parent; 11557 else { 11558 t = parent.predicate("fhir:"+parentType+'.'+name); 11559 } 11560 composeBackboneElement(t, "parameter", name, element, index); 11561 if (element.hasValue()) 11562 composeType(t, "StructureMap", "value", element.getValue(), -1); 11563 } 11564 11565 protected void composeStructureMapStructureMapGroupRuleDependentComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleDependentComponent element, int index) { 11566 if (element == null) 11567 return; 11568 Complex t; 11569 if (Utilities.noString(parentType)) 11570 t = parent; 11571 else { 11572 t = parent.predicate("fhir:"+parentType+'.'+name); 11573 } 11574 composeBackboneElement(t, "dependent", name, element, index); 11575 if (element.hasNameElement()) 11576 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 11577 for (int i = 0; i < element.getVariable().size(); i++) 11578 composeString(t, "StructureMap", "variable", element.getVariable().get(i), i); 11579 } 11580 11581 protected void composeSubscription(Complex parent, String parentType, String name, Subscription element, int index) { 11582 if (element == null) 11583 return; 11584 Complex t; 11585 if (Utilities.noString(parentType)) 11586 t = parent; 11587 else { 11588 t = parent.predicate("fhir:"+parentType+'.'+name); 11589 } 11590 composeDomainResource(t, "Subscription", name, element, index); 11591 if (element.hasStatusElement()) 11592 composeEnum(t, "Subscription", "status", element.getStatusElement(), -1); 11593 for (int i = 0; i < element.getContact().size(); i++) 11594 composeContactPoint(t, "Subscription", "contact", element.getContact().get(i), i); 11595 if (element.hasEndElement()) 11596 composeInstant(t, "Subscription", "end", element.getEndElement(), -1); 11597 if (element.hasReasonElement()) 11598 composeString(t, "Subscription", "reason", element.getReasonElement(), -1); 11599 if (element.hasCriteriaElement()) 11600 composeString(t, "Subscription", "criteria", element.getCriteriaElement(), -1); 11601 if (element.hasErrorElement()) 11602 composeString(t, "Subscription", "error", element.getErrorElement(), -1); 11603 if (element.hasChannel()) 11604 composeSubscriptionSubscriptionChannelComponent(t, "Subscription", "channel", element.getChannel(), -1); 11605 for (int i = 0; i < element.getTag().size(); i++) 11606 composeCoding(t, "Subscription", "tag", element.getTag().get(i), i); 11607 } 11608 11609 protected void composeSubscriptionSubscriptionChannelComponent(Complex parent, String parentType, String name, Subscription.SubscriptionChannelComponent element, int index) { 11610 if (element == null) 11611 return; 11612 Complex t; 11613 if (Utilities.noString(parentType)) 11614 t = parent; 11615 else { 11616 t = parent.predicate("fhir:"+parentType+'.'+name); 11617 } 11618 composeBackboneElement(t, "channel", name, element, index); 11619 if (element.hasTypeElement()) 11620 composeEnum(t, "Subscription", "type", element.getTypeElement(), -1); 11621 if (element.hasEndpointElement()) 11622 composeUri(t, "Subscription", "endpoint", element.getEndpointElement(), -1); 11623 if (element.hasPayloadElement()) 11624 composeString(t, "Subscription", "payload", element.getPayloadElement(), -1); 11625 for (int i = 0; i < element.getHeader().size(); i++) 11626 composeString(t, "Subscription", "header", element.getHeader().get(i), i); 11627 } 11628 11629 protected void composeSubstance(Complex parent, String parentType, String name, Substance 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 composeDomainResource(t, "Substance", name, element, index); 11639 for (int i = 0; i < element.getIdentifier().size(); i++) 11640 composeIdentifier(t, "Substance", "identifier", element.getIdentifier().get(i), i); 11641 if (element.hasStatusElement()) 11642 composeEnum(t, "Substance", "status", element.getStatusElement(), -1); 11643 for (int i = 0; i < element.getCategory().size(); i++) 11644 composeCodeableConcept(t, "Substance", "category", element.getCategory().get(i), i); 11645 if (element.hasCode()) 11646 composeCodeableConcept(t, "Substance", "code", element.getCode(), -1); 11647 if (element.hasDescriptionElement()) 11648 composeString(t, "Substance", "description", element.getDescriptionElement(), -1); 11649 for (int i = 0; i < element.getInstance().size(); i++) 11650 composeSubstanceSubstanceInstanceComponent(t, "Substance", "instance", element.getInstance().get(i), i); 11651 for (int i = 0; i < element.getIngredient().size(); i++) 11652 composeSubstanceSubstanceIngredientComponent(t, "Substance", "ingredient", element.getIngredient().get(i), i); 11653 } 11654 11655 protected void composeSubstanceSubstanceInstanceComponent(Complex parent, String parentType, String name, Substance.SubstanceInstanceComponent element, int index) { 11656 if (element == null) 11657 return; 11658 Complex t; 11659 if (Utilities.noString(parentType)) 11660 t = parent; 11661 else { 11662 t = parent.predicate("fhir:"+parentType+'.'+name); 11663 } 11664 composeBackboneElement(t, "instance", name, element, index); 11665 if (element.hasIdentifier()) 11666 composeIdentifier(t, "Substance", "identifier", element.getIdentifier(), -1); 11667 if (element.hasExpiryElement()) 11668 composeDateTime(t, "Substance", "expiry", element.getExpiryElement(), -1); 11669 if (element.hasQuantity()) 11670 composeQuantity(t, "Substance", "quantity", element.getQuantity(), -1); 11671 } 11672 11673 protected void composeSubstanceSubstanceIngredientComponent(Complex parent, String parentType, String name, Substance.SubstanceIngredientComponent element, int index) { 11674 if (element == null) 11675 return; 11676 Complex t; 11677 if (Utilities.noString(parentType)) 11678 t = parent; 11679 else { 11680 t = parent.predicate("fhir:"+parentType+'.'+name); 11681 } 11682 composeBackboneElement(t, "ingredient", name, element, index); 11683 if (element.hasQuantity()) 11684 composeRatio(t, "Substance", "quantity", element.getQuantity(), -1); 11685 if (element.hasSubstance()) 11686 composeType(t, "Substance", "substance", element.getSubstance(), -1); 11687 } 11688 11689 protected void composeSupplyDelivery(Complex parent, String parentType, String name, SupplyDelivery element, int index) { 11690 if (element == null) 11691 return; 11692 Complex t; 11693 if (Utilities.noString(parentType)) 11694 t = parent; 11695 else { 11696 t = parent.predicate("fhir:"+parentType+'.'+name); 11697 } 11698 composeDomainResource(t, "SupplyDelivery", name, element, index); 11699 if (element.hasIdentifier()) 11700 composeIdentifier(t, "SupplyDelivery", "identifier", element.getIdentifier(), -1); 11701 for (int i = 0; i < element.getBasedOn().size(); i++) 11702 composeReference(t, "SupplyDelivery", "basedOn", element.getBasedOn().get(i), i); 11703 for (int i = 0; i < element.getPartOf().size(); i++) 11704 composeReference(t, "SupplyDelivery", "partOf", element.getPartOf().get(i), i); 11705 if (element.hasStatusElement()) 11706 composeEnum(t, "SupplyDelivery", "status", element.getStatusElement(), -1); 11707 if (element.hasPatient()) 11708 composeReference(t, "SupplyDelivery", "patient", element.getPatient(), -1); 11709 if (element.hasType()) 11710 composeCodeableConcept(t, "SupplyDelivery", "type", element.getType(), -1); 11711 if (element.hasSuppliedItem()) 11712 composeSupplyDeliverySupplyDeliverySuppliedItemComponent(t, "SupplyDelivery", "suppliedItem", element.getSuppliedItem(), -1); 11713 if (element.hasOccurrence()) 11714 composeType(t, "SupplyDelivery", "occurrence", element.getOccurrence(), -1); 11715 if (element.hasSupplier()) 11716 composeReference(t, "SupplyDelivery", "supplier", element.getSupplier(), -1); 11717 if (element.hasDestination()) 11718 composeReference(t, "SupplyDelivery", "destination", element.getDestination(), -1); 11719 for (int i = 0; i < element.getReceiver().size(); i++) 11720 composeReference(t, "SupplyDelivery", "receiver", element.getReceiver().get(i), i); 11721 } 11722 11723 protected void composeSupplyDeliverySupplyDeliverySuppliedItemComponent(Complex parent, String parentType, String name, SupplyDelivery.SupplyDeliverySuppliedItemComponent element, int index) { 11724 if (element == null) 11725 return; 11726 Complex t; 11727 if (Utilities.noString(parentType)) 11728 t = parent; 11729 else { 11730 t = parent.predicate("fhir:"+parentType+'.'+name); 11731 } 11732 composeBackboneElement(t, "suppliedItem", name, element, index); 11733 if (element.hasQuantity()) 11734 composeQuantity(t, "SupplyDelivery", "quantity", element.getQuantity(), -1); 11735 if (element.hasItem()) 11736 composeType(t, "SupplyDelivery", "item", element.getItem(), -1); 11737 } 11738 11739 protected void composeSupplyRequest(Complex parent, String parentType, String name, SupplyRequest element, int index) { 11740 if (element == null) 11741 return; 11742 Complex t; 11743 if (Utilities.noString(parentType)) 11744 t = parent; 11745 else { 11746 t = parent.predicate("fhir:"+parentType+'.'+name); 11747 } 11748 composeDomainResource(t, "SupplyRequest", name, element, index); 11749 if (element.hasIdentifier()) 11750 composeIdentifier(t, "SupplyRequest", "identifier", element.getIdentifier(), -1); 11751 if (element.hasStatusElement()) 11752 composeEnum(t, "SupplyRequest", "status", element.getStatusElement(), -1); 11753 if (element.hasCategory()) 11754 composeCodeableConcept(t, "SupplyRequest", "category", element.getCategory(), -1); 11755 if (element.hasPriorityElement()) 11756 composeEnum(t, "SupplyRequest", "priority", element.getPriorityElement(), -1); 11757 if (element.hasOrderedItem()) 11758 composeSupplyRequestSupplyRequestOrderedItemComponent(t, "SupplyRequest", "orderedItem", element.getOrderedItem(), -1); 11759 if (element.hasOccurrence()) 11760 composeType(t, "SupplyRequest", "occurrence", element.getOccurrence(), -1); 11761 if (element.hasAuthoredOnElement()) 11762 composeDateTime(t, "SupplyRequest", "authoredOn", element.getAuthoredOnElement(), -1); 11763 if (element.hasRequester()) 11764 composeSupplyRequestSupplyRequestRequesterComponent(t, "SupplyRequest", "requester", element.getRequester(), -1); 11765 for (int i = 0; i < element.getSupplier().size(); i++) 11766 composeReference(t, "SupplyRequest", "supplier", element.getSupplier().get(i), i); 11767 if (element.hasReason()) 11768 composeType(t, "SupplyRequest", "reason", element.getReason(), -1); 11769 if (element.hasDeliverFrom()) 11770 composeReference(t, "SupplyRequest", "deliverFrom", element.getDeliverFrom(), -1); 11771 if (element.hasDeliverTo()) 11772 composeReference(t, "SupplyRequest", "deliverTo", element.getDeliverTo(), -1); 11773 } 11774 11775 protected void composeSupplyRequestSupplyRequestOrderedItemComponent(Complex parent, String parentType, String name, SupplyRequest.SupplyRequestOrderedItemComponent element, int index) { 11776 if (element == null) 11777 return; 11778 Complex t; 11779 if (Utilities.noString(parentType)) 11780 t = parent; 11781 else { 11782 t = parent.predicate("fhir:"+parentType+'.'+name); 11783 } 11784 composeBackboneElement(t, "orderedItem", name, element, index); 11785 if (element.hasQuantity()) 11786 composeQuantity(t, "SupplyRequest", "quantity", element.getQuantity(), -1); 11787 if (element.hasItem()) 11788 composeType(t, "SupplyRequest", "item", element.getItem(), -1); 11789 } 11790 11791 protected void composeSupplyRequestSupplyRequestRequesterComponent(Complex parent, String parentType, String name, SupplyRequest.SupplyRequestRequesterComponent element, int index) { 11792 if (element == null) 11793 return; 11794 Complex t; 11795 if (Utilities.noString(parentType)) 11796 t = parent; 11797 else { 11798 t = parent.predicate("fhir:"+parentType+'.'+name); 11799 } 11800 composeBackboneElement(t, "requester", name, element, index); 11801 if (element.hasAgent()) 11802 composeReference(t, "SupplyRequest", "agent", element.getAgent(), -1); 11803 if (element.hasOnBehalfOf()) 11804 composeReference(t, "SupplyRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 11805 } 11806 11807 protected void composeTask(Complex parent, String parentType, String name, Task element, int index) { 11808 if (element == null) 11809 return; 11810 Complex t; 11811 if (Utilities.noString(parentType)) 11812 t = parent; 11813 else { 11814 t = parent.predicate("fhir:"+parentType+'.'+name); 11815 } 11816 composeDomainResource(t, "Task", name, element, index); 11817 for (int i = 0; i < element.getIdentifier().size(); i++) 11818 composeIdentifier(t, "Task", "identifier", element.getIdentifier().get(i), i); 11819 if (element.hasDefinition()) 11820 composeType(t, "Task", "definition", element.getDefinition(), -1); 11821 for (int i = 0; i < element.getBasedOn().size(); i++) 11822 composeReference(t, "Task", "basedOn", element.getBasedOn().get(i), i); 11823 if (element.hasGroupIdentifier()) 11824 composeIdentifier(t, "Task", "groupIdentifier", element.getGroupIdentifier(), -1); 11825 for (int i = 0; i < element.getPartOf().size(); i++) 11826 composeReference(t, "Task", "partOf", element.getPartOf().get(i), i); 11827 if (element.hasStatusElement()) 11828 composeEnum(t, "Task", "status", element.getStatusElement(), -1); 11829 if (element.hasStatusReason()) 11830 composeCodeableConcept(t, "Task", "statusReason", element.getStatusReason(), -1); 11831 if (element.hasBusinessStatus()) 11832 composeCodeableConcept(t, "Task", "businessStatus", element.getBusinessStatus(), -1); 11833 if (element.hasIntentElement()) 11834 composeEnum(t, "Task", "intent", element.getIntentElement(), -1); 11835 if (element.hasPriorityElement()) 11836 composeEnum(t, "Task", "priority", element.getPriorityElement(), -1); 11837 if (element.hasCode()) 11838 composeCodeableConcept(t, "Task", "code", element.getCode(), -1); 11839 if (element.hasDescriptionElement()) 11840 composeString(t, "Task", "description", element.getDescriptionElement(), -1); 11841 if (element.hasFocus()) 11842 composeReference(t, "Task", "focus", element.getFocus(), -1); 11843 if (element.hasFor()) 11844 composeReference(t, "Task", "for", element.getFor(), -1); 11845 if (element.hasContext()) 11846 composeReference(t, "Task", "context", element.getContext(), -1); 11847 if (element.hasExecutionPeriod()) 11848 composePeriod(t, "Task", "executionPeriod", element.getExecutionPeriod(), -1); 11849 if (element.hasAuthoredOnElement()) 11850 composeDateTime(t, "Task", "authoredOn", element.getAuthoredOnElement(), -1); 11851 if (element.hasLastModifiedElement()) 11852 composeDateTime(t, "Task", "lastModified", element.getLastModifiedElement(), -1); 11853 if (element.hasRequester()) 11854 composeTaskTaskRequesterComponent(t, "Task", "requester", element.getRequester(), -1); 11855 for (int i = 0; i < element.getPerformerType().size(); i++) 11856 composeCodeableConcept(t, "Task", "performerType", element.getPerformerType().get(i), i); 11857 if (element.hasOwner()) 11858 composeReference(t, "Task", "owner", element.getOwner(), -1); 11859 if (element.hasReason()) 11860 composeCodeableConcept(t, "Task", "reason", element.getReason(), -1); 11861 for (int i = 0; i < element.getNote().size(); i++) 11862 composeAnnotation(t, "Task", "note", element.getNote().get(i), i); 11863 for (int i = 0; i < element.getRelevantHistory().size(); i++) 11864 composeReference(t, "Task", "relevantHistory", element.getRelevantHistory().get(i), i); 11865 if (element.hasRestriction()) 11866 composeTaskTaskRestrictionComponent(t, "Task", "restriction", element.getRestriction(), -1); 11867 for (int i = 0; i < element.getInput().size(); i++) 11868 composeTaskParameterComponent(t, "Task", "input", element.getInput().get(i), i); 11869 for (int i = 0; i < element.getOutput().size(); i++) 11870 composeTaskTaskOutputComponent(t, "Task", "output", element.getOutput().get(i), i); 11871 } 11872 11873 protected void composeTaskTaskRequesterComponent(Complex parent, String parentType, String name, Task.TaskRequesterComponent element, int index) { 11874 if (element == null) 11875 return; 11876 Complex t; 11877 if (Utilities.noString(parentType)) 11878 t = parent; 11879 else { 11880 t = parent.predicate("fhir:"+parentType+'.'+name); 11881 } 11882 composeBackboneElement(t, "requester", name, element, index); 11883 if (element.hasAgent()) 11884 composeReference(t, "Task", "agent", element.getAgent(), -1); 11885 if (element.hasOnBehalfOf()) 11886 composeReference(t, "Task", "onBehalfOf", element.getOnBehalfOf(), -1); 11887 } 11888 11889 protected void composeTaskTaskRestrictionComponent(Complex parent, String parentType, String name, Task.TaskRestrictionComponent element, int index) { 11890 if (element == null) 11891 return; 11892 Complex t; 11893 if (Utilities.noString(parentType)) 11894 t = parent; 11895 else { 11896 t = parent.predicate("fhir:"+parentType+'.'+name); 11897 } 11898 composeBackboneElement(t, "restriction", name, element, index); 11899 if (element.hasRepetitionsElement()) 11900 composePositiveInt(t, "Task", "repetitions", element.getRepetitionsElement(), -1); 11901 if (element.hasPeriod()) 11902 composePeriod(t, "Task", "period", element.getPeriod(), -1); 11903 for (int i = 0; i < element.getRecipient().size(); i++) 11904 composeReference(t, "Task", "recipient", element.getRecipient().get(i), i); 11905 } 11906 11907 protected void composeTaskParameterComponent(Complex parent, String parentType, String name, Task.ParameterComponent element, int index) { 11908 if (element == null) 11909 return; 11910 Complex t; 11911 if (Utilities.noString(parentType)) 11912 t = parent; 11913 else { 11914 t = parent.predicate("fhir:"+parentType+'.'+name); 11915 } 11916 composeBackboneElement(t, "input", name, element, index); 11917 if (element.hasType()) 11918 composeCodeableConcept(t, "Task", "type", element.getType(), -1); 11919 if (element.hasValue()) 11920 composeType(t, "Task", "value", element.getValue(), -1); 11921 } 11922 11923 protected void composeTaskTaskOutputComponent(Complex parent, String parentType, String name, Task.TaskOutputComponent element, int index) { 11924 if (element == null) 11925 return; 11926 Complex t; 11927 if (Utilities.noString(parentType)) 11928 t = parent; 11929 else { 11930 t = parent.predicate("fhir:"+parentType+'.'+name); 11931 } 11932 composeBackboneElement(t, "output", name, element, index); 11933 if (element.hasType()) 11934 composeCodeableConcept(t, "Task", "type", element.getType(), -1); 11935 if (element.hasValue()) 11936 composeType(t, "Task", "value", element.getValue(), -1); 11937 } 11938 11939 protected void composeTestReport(Complex parent, String parentType, String name, TestReport element, int index) { 11940 if (element == null) 11941 return; 11942 Complex t; 11943 if (Utilities.noString(parentType)) 11944 t = parent; 11945 else { 11946 t = parent.predicate("fhir:"+parentType+'.'+name); 11947 } 11948 composeDomainResource(t, "TestReport", name, element, index); 11949 if (element.hasIdentifier()) 11950 composeIdentifier(t, "TestReport", "identifier", element.getIdentifier(), -1); 11951 if (element.hasNameElement()) 11952 composeString(t, "TestReport", "name", element.getNameElement(), -1); 11953 if (element.hasStatusElement()) 11954 composeEnum(t, "TestReport", "status", element.getStatusElement(), -1); 11955 if (element.hasTestScript()) 11956 composeReference(t, "TestReport", "testScript", element.getTestScript(), -1); 11957 if (element.hasResultElement()) 11958 composeEnum(t, "TestReport", "result", element.getResultElement(), -1); 11959 if (element.hasScoreElement()) 11960 composeDecimal(t, "TestReport", "score", element.getScoreElement(), -1); 11961 if (element.hasTesterElement()) 11962 composeString(t, "TestReport", "tester", element.getTesterElement(), -1); 11963 if (element.hasIssuedElement()) 11964 composeDateTime(t, "TestReport", "issued", element.getIssuedElement(), -1); 11965 for (int i = 0; i < element.getParticipant().size(); i++) 11966 composeTestReportTestReportParticipantComponent(t, "TestReport", "participant", element.getParticipant().get(i), i); 11967 if (element.hasSetup()) 11968 composeTestReportTestReportSetupComponent(t, "TestReport", "setup", element.getSetup(), -1); 11969 for (int i = 0; i < element.getTest().size(); i++) 11970 composeTestReportTestReportTestComponent(t, "TestReport", "test", element.getTest().get(i), i); 11971 if (element.hasTeardown()) 11972 composeTestReportTestReportTeardownComponent(t, "TestReport", "teardown", element.getTeardown(), -1); 11973 } 11974 11975 protected void composeTestReportTestReportParticipantComponent(Complex parent, String parentType, String name, TestReport.TestReportParticipantComponent element, int index) { 11976 if (element == null) 11977 return; 11978 Complex t; 11979 if (Utilities.noString(parentType)) 11980 t = parent; 11981 else { 11982 t = parent.predicate("fhir:"+parentType+'.'+name); 11983 } 11984 composeBackboneElement(t, "participant", name, element, index); 11985 if (element.hasTypeElement()) 11986 composeEnum(t, "TestReport", "type", element.getTypeElement(), -1); 11987 if (element.hasUriElement()) 11988 composeUri(t, "TestReport", "uri", element.getUriElement(), -1); 11989 if (element.hasDisplayElement()) 11990 composeString(t, "TestReport", "display", element.getDisplayElement(), -1); 11991 } 11992 11993 protected void composeTestReportTestReportSetupComponent(Complex parent, String parentType, String name, TestReport.TestReportSetupComponent element, int index) { 11994 if (element == null) 11995 return; 11996 Complex t; 11997 if (Utilities.noString(parentType)) 11998 t = parent; 11999 else { 12000 t = parent.predicate("fhir:"+parentType+'.'+name); 12001 } 12002 composeBackboneElement(t, "setup", name, element, index); 12003 for (int i = 0; i < element.getAction().size(); i++) 12004 composeTestReportSetupActionComponent(t, "TestReport", "action", element.getAction().get(i), i); 12005 } 12006 12007 protected void composeTestReportSetupActionComponent(Complex parent, String parentType, String name, TestReport.SetupActionComponent element, int index) { 12008 if (element == null) 12009 return; 12010 Complex t; 12011 if (Utilities.noString(parentType)) 12012 t = parent; 12013 else { 12014 t = parent.predicate("fhir:"+parentType+'.'+name); 12015 } 12016 composeBackboneElement(t, "action", name, element, index); 12017 if (element.hasOperation()) 12018 composeTestReportSetupActionOperationComponent(t, "TestReport", "operation", element.getOperation(), -1); 12019 if (element.hasAssert()) 12020 composeTestReportSetupActionAssertComponent(t, "TestReport", "assert", element.getAssert(), -1); 12021 } 12022 12023 protected void composeTestReportSetupActionOperationComponent(Complex parent, String parentType, String name, TestReport.SetupActionOperationComponent element, int index) { 12024 if (element == null) 12025 return; 12026 Complex t; 12027 if (Utilities.noString(parentType)) 12028 t = parent; 12029 else { 12030 t = parent.predicate("fhir:"+parentType+'.'+name); 12031 } 12032 composeBackboneElement(t, "operation", name, element, index); 12033 if (element.hasResultElement()) 12034 composeEnum(t, "TestReport", "result", element.getResultElement(), -1); 12035 if (element.hasMessageElement()) 12036 composeMarkdown(t, "TestReport", "message", element.getMessageElement(), -1); 12037 if (element.hasDetailElement()) 12038 composeUri(t, "TestReport", "detail", element.getDetailElement(), -1); 12039 } 12040 12041 protected void composeTestReportSetupActionAssertComponent(Complex parent, String parentType, String name, TestReport.SetupActionAssertComponent element, int index) { 12042 if (element == null) 12043 return; 12044 Complex t; 12045 if (Utilities.noString(parentType)) 12046 t = parent; 12047 else { 12048 t = parent.predicate("fhir:"+parentType+'.'+name); 12049 } 12050 composeBackboneElement(t, "assert", name, element, index); 12051 if (element.hasResultElement()) 12052 composeEnum(t, "TestReport", "result", element.getResultElement(), -1); 12053 if (element.hasMessageElement()) 12054 composeMarkdown(t, "TestReport", "message", element.getMessageElement(), -1); 12055 if (element.hasDetailElement()) 12056 composeString(t, "TestReport", "detail", element.getDetailElement(), -1); 12057 } 12058 12059 protected void composeTestReportTestReportTestComponent(Complex parent, String parentType, String name, TestReport.TestReportTestComponent element, int index) { 12060 if (element == null) 12061 return; 12062 Complex t; 12063 if (Utilities.noString(parentType)) 12064 t = parent; 12065 else { 12066 t = parent.predicate("fhir:"+parentType+'.'+name); 12067 } 12068 composeBackboneElement(t, "test", name, element, index); 12069 if (element.hasNameElement()) 12070 composeString(t, "TestReport", "name", element.getNameElement(), -1); 12071 if (element.hasDescriptionElement()) 12072 composeString(t, "TestReport", "description", element.getDescriptionElement(), -1); 12073 for (int i = 0; i < element.getAction().size(); i++) 12074 composeTestReportTestActionComponent(t, "TestReport", "action", element.getAction().get(i), i); 12075 } 12076 12077 protected void composeTestReportTestActionComponent(Complex parent, String parentType, String name, TestReport.TestActionComponent element, int index) { 12078 if (element == null) 12079 return; 12080 Complex t; 12081 if (Utilities.noString(parentType)) 12082 t = parent; 12083 else { 12084 t = parent.predicate("fhir:"+parentType+'.'+name); 12085 } 12086 composeBackboneElement(t, "action", name, element, index); 12087 if (element.hasOperation()) 12088 composeTestReportSetupActionOperationComponent(t, "TestReport", "operation", element.getOperation(), -1); 12089 if (element.hasAssert()) 12090 composeTestReportSetupActionAssertComponent(t, "TestReport", "assert", element.getAssert(), -1); 12091 } 12092 12093 protected void composeTestReportTestReportTeardownComponent(Complex parent, String parentType, String name, TestReport.TestReportTeardownComponent element, int index) { 12094 if (element == null) 12095 return; 12096 Complex t; 12097 if (Utilities.noString(parentType)) 12098 t = parent; 12099 else { 12100 t = parent.predicate("fhir:"+parentType+'.'+name); 12101 } 12102 composeBackboneElement(t, "teardown", name, element, index); 12103 for (int i = 0; i < element.getAction().size(); i++) 12104 composeTestReportTeardownActionComponent(t, "TestReport", "action", element.getAction().get(i), i); 12105 } 12106 12107 protected void composeTestReportTeardownActionComponent(Complex parent, String parentType, String name, TestReport.TeardownActionComponent element, int index) { 12108 if (element == null) 12109 return; 12110 Complex t; 12111 if (Utilities.noString(parentType)) 12112 t = parent; 12113 else { 12114 t = parent.predicate("fhir:"+parentType+'.'+name); 12115 } 12116 composeBackboneElement(t, "action", name, element, index); 12117 if (element.hasOperation()) 12118 composeTestReportSetupActionOperationComponent(t, "TestReport", "operation", element.getOperation(), -1); 12119 } 12120 12121 protected void composeTestScript(Complex parent, String parentType, String name, TestScript element, int index) { 12122 if (element == null) 12123 return; 12124 Complex t; 12125 if (Utilities.noString(parentType)) 12126 t = parent; 12127 else { 12128 t = parent.predicate("fhir:"+parentType+'.'+name); 12129 } 12130 composeDomainResource(t, "TestScript", name, element, index); 12131 if (element.hasUrlElement()) 12132 composeUri(t, "TestScript", "url", element.getUrlElement(), -1); 12133 if (element.hasIdentifier()) 12134 composeIdentifier(t, "TestScript", "identifier", element.getIdentifier(), -1); 12135 if (element.hasVersionElement()) 12136 composeString(t, "TestScript", "version", element.getVersionElement(), -1); 12137 if (element.hasNameElement()) 12138 composeString(t, "TestScript", "name", element.getNameElement(), -1); 12139 if (element.hasTitleElement()) 12140 composeString(t, "TestScript", "title", element.getTitleElement(), -1); 12141 if (element.hasStatusElement()) 12142 composeEnum(t, "TestScript", "status", element.getStatusElement(), -1); 12143 if (element.hasExperimentalElement()) 12144 composeBoolean(t, "TestScript", "experimental", element.getExperimentalElement(), -1); 12145 if (element.hasDateElement()) 12146 composeDateTime(t, "TestScript", "date", element.getDateElement(), -1); 12147 if (element.hasPublisherElement()) 12148 composeString(t, "TestScript", "publisher", element.getPublisherElement(), -1); 12149 for (int i = 0; i < element.getContact().size(); i++) 12150 composeContactDetail(t, "TestScript", "contact", element.getContact().get(i), i); 12151 if (element.hasDescriptionElement()) 12152 composeMarkdown(t, "TestScript", "description", element.getDescriptionElement(), -1); 12153 for (int i = 0; i < element.getUseContext().size(); i++) 12154 composeUsageContext(t, "TestScript", "useContext", element.getUseContext().get(i), i); 12155 for (int i = 0; i < element.getJurisdiction().size(); i++) 12156 composeCodeableConcept(t, "TestScript", "jurisdiction", element.getJurisdiction().get(i), i); 12157 if (element.hasPurposeElement()) 12158 composeMarkdown(t, "TestScript", "purpose", element.getPurposeElement(), -1); 12159 if (element.hasCopyrightElement()) 12160 composeMarkdown(t, "TestScript", "copyright", element.getCopyrightElement(), -1); 12161 for (int i = 0; i < element.getOrigin().size(); i++) 12162 composeTestScriptTestScriptOriginComponent(t, "TestScript", "origin", element.getOrigin().get(i), i); 12163 for (int i = 0; i < element.getDestination().size(); i++) 12164 composeTestScriptTestScriptDestinationComponent(t, "TestScript", "destination", element.getDestination().get(i), i); 12165 if (element.hasMetadata()) 12166 composeTestScriptTestScriptMetadataComponent(t, "TestScript", "metadata", element.getMetadata(), -1); 12167 for (int i = 0; i < element.getFixture().size(); i++) 12168 composeTestScriptTestScriptFixtureComponent(t, "TestScript", "fixture", element.getFixture().get(i), i); 12169 for (int i = 0; i < element.getProfile().size(); i++) 12170 composeReference(t, "TestScript", "profile", element.getProfile().get(i), i); 12171 for (int i = 0; i < element.getVariable().size(); i++) 12172 composeTestScriptTestScriptVariableComponent(t, "TestScript", "variable", element.getVariable().get(i), i); 12173 for (int i = 0; i < element.getRule().size(); i++) 12174 composeTestScriptTestScriptRuleComponent(t, "TestScript", "rule", element.getRule().get(i), i); 12175 for (int i = 0; i < element.getRuleset().size(); i++) 12176 composeTestScriptTestScriptRulesetComponent(t, "TestScript", "ruleset", element.getRuleset().get(i), i); 12177 if (element.hasSetup()) 12178 composeTestScriptTestScriptSetupComponent(t, "TestScript", "setup", element.getSetup(), -1); 12179 for (int i = 0; i < element.getTest().size(); i++) 12180 composeTestScriptTestScriptTestComponent(t, "TestScript", "test", element.getTest().get(i), i); 12181 if (element.hasTeardown()) 12182 composeTestScriptTestScriptTeardownComponent(t, "TestScript", "teardown", element.getTeardown(), -1); 12183 } 12184 12185 protected void composeTestScriptTestScriptOriginComponent(Complex parent, String parentType, String name, TestScript.TestScriptOriginComponent element, int index) { 12186 if (element == null) 12187 return; 12188 Complex t; 12189 if (Utilities.noString(parentType)) 12190 t = parent; 12191 else { 12192 t = parent.predicate("fhir:"+parentType+'.'+name); 12193 } 12194 composeBackboneElement(t, "origin", name, element, index); 12195 if (element.hasIndexElement()) 12196 composeInteger(t, "TestScript", "index", element.getIndexElement(), -1); 12197 if (element.hasProfile()) 12198 composeCoding(t, "TestScript", "profile", element.getProfile(), -1); 12199 } 12200 12201 protected void composeTestScriptTestScriptDestinationComponent(Complex parent, String parentType, String name, TestScript.TestScriptDestinationComponent element, int index) { 12202 if (element == null) 12203 return; 12204 Complex t; 12205 if (Utilities.noString(parentType)) 12206 t = parent; 12207 else { 12208 t = parent.predicate("fhir:"+parentType+'.'+name); 12209 } 12210 composeBackboneElement(t, "destination", name, element, index); 12211 if (element.hasIndexElement()) 12212 composeInteger(t, "TestScript", "index", element.getIndexElement(), -1); 12213 if (element.hasProfile()) 12214 composeCoding(t, "TestScript", "profile", element.getProfile(), -1); 12215 } 12216 12217 protected void composeTestScriptTestScriptMetadataComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataComponent element, int index) { 12218 if (element == null) 12219 return; 12220 Complex t; 12221 if (Utilities.noString(parentType)) 12222 t = parent; 12223 else { 12224 t = parent.predicate("fhir:"+parentType+'.'+name); 12225 } 12226 composeBackboneElement(t, "metadata", name, element, index); 12227 for (int i = 0; i < element.getLink().size(); i++) 12228 composeTestScriptTestScriptMetadataLinkComponent(t, "TestScript", "link", element.getLink().get(i), i); 12229 for (int i = 0; i < element.getCapability().size(); i++) 12230 composeTestScriptTestScriptMetadataCapabilityComponent(t, "TestScript", "capability", element.getCapability().get(i), i); 12231 } 12232 12233 protected void composeTestScriptTestScriptMetadataLinkComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataLinkComponent element, int index) { 12234 if (element == null) 12235 return; 12236 Complex t; 12237 if (Utilities.noString(parentType)) 12238 t = parent; 12239 else { 12240 t = parent.predicate("fhir:"+parentType+'.'+name); 12241 } 12242 composeBackboneElement(t, "link", name, element, index); 12243 if (element.hasUrlElement()) 12244 composeUri(t, "TestScript", "url", element.getUrlElement(), -1); 12245 if (element.hasDescriptionElement()) 12246 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 12247 } 12248 12249 protected void composeTestScriptTestScriptMetadataCapabilityComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataCapabilityComponent element, int index) { 12250 if (element == null) 12251 return; 12252 Complex t; 12253 if (Utilities.noString(parentType)) 12254 t = parent; 12255 else { 12256 t = parent.predicate("fhir:"+parentType+'.'+name); 12257 } 12258 composeBackboneElement(t, "capability", name, element, index); 12259 if (element.hasRequiredElement()) 12260 composeBoolean(t, "TestScript", "required", element.getRequiredElement(), -1); 12261 if (element.hasValidatedElement()) 12262 composeBoolean(t, "TestScript", "validated", element.getValidatedElement(), -1); 12263 if (element.hasDescriptionElement()) 12264 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 12265 for (int i = 0; i < element.getOrigin().size(); i++) 12266 composeInteger(t, "TestScript", "origin", element.getOrigin().get(i), i); 12267 if (element.hasDestinationElement()) 12268 composeInteger(t, "TestScript", "destination", element.getDestinationElement(), -1); 12269 for (int i = 0; i < element.getLink().size(); i++) 12270 composeUri(t, "TestScript", "link", element.getLink().get(i), i); 12271 if (element.hasCapabilities()) 12272 composeReference(t, "TestScript", "capabilities", element.getCapabilities(), -1); 12273 } 12274 12275 protected void composeTestScriptTestScriptFixtureComponent(Complex parent, String parentType, String name, TestScript.TestScriptFixtureComponent element, int index) { 12276 if (element == null) 12277 return; 12278 Complex t; 12279 if (Utilities.noString(parentType)) 12280 t = parent; 12281 else { 12282 t = parent.predicate("fhir:"+parentType+'.'+name); 12283 } 12284 composeBackboneElement(t, "fixture", name, element, index); 12285 if (element.hasAutocreateElement()) 12286 composeBoolean(t, "TestScript", "autocreate", element.getAutocreateElement(), -1); 12287 if (element.hasAutodeleteElement()) 12288 composeBoolean(t, "TestScript", "autodelete", element.getAutodeleteElement(), -1); 12289 if (element.hasResource()) 12290 composeReference(t, "TestScript", "resource", element.getResource(), -1); 12291 } 12292 12293 protected void composeTestScriptTestScriptVariableComponent(Complex parent, String parentType, String name, TestScript.TestScriptVariableComponent element, int index) { 12294 if (element == null) 12295 return; 12296 Complex t; 12297 if (Utilities.noString(parentType)) 12298 t = parent; 12299 else { 12300 t = parent.predicate("fhir:"+parentType+'.'+name); 12301 } 12302 composeBackboneElement(t, "variable", name, element, index); 12303 if (element.hasNameElement()) 12304 composeString(t, "TestScript", "name", element.getNameElement(), -1); 12305 if (element.hasDefaultValueElement()) 12306 composeString(t, "TestScript", "defaultValue", element.getDefaultValueElement(), -1); 12307 if (element.hasDescriptionElement()) 12308 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 12309 if (element.hasExpressionElement()) 12310 composeString(t, "TestScript", "expression", element.getExpressionElement(), -1); 12311 if (element.hasHeaderFieldElement()) 12312 composeString(t, "TestScript", "headerField", element.getHeaderFieldElement(), -1); 12313 if (element.hasHintElement()) 12314 composeString(t, "TestScript", "hint", element.getHintElement(), -1); 12315 if (element.hasPathElement()) 12316 composeString(t, "TestScript", "path", element.getPathElement(), -1); 12317 if (element.hasSourceIdElement()) 12318 composeId(t, "TestScript", "sourceId", element.getSourceIdElement(), -1); 12319 } 12320 12321 protected void composeTestScriptTestScriptRuleComponent(Complex parent, String parentType, String name, TestScript.TestScriptRuleComponent element, int index) { 12322 if (element == null) 12323 return; 12324 Complex t; 12325 if (Utilities.noString(parentType)) 12326 t = parent; 12327 else { 12328 t = parent.predicate("fhir:"+parentType+'.'+name); 12329 } 12330 composeBackboneElement(t, "rule", name, element, index); 12331 if (element.hasResource()) 12332 composeReference(t, "TestScript", "resource", element.getResource(), -1); 12333 for (int i = 0; i < element.getParam().size(); i++) 12334 composeTestScriptRuleParamComponent(t, "TestScript", "param", element.getParam().get(i), i); 12335 } 12336 12337 protected void composeTestScriptRuleParamComponent(Complex parent, String parentType, String name, TestScript.RuleParamComponent element, int index) { 12338 if (element == null) 12339 return; 12340 Complex t; 12341 if (Utilities.noString(parentType)) 12342 t = parent; 12343 else { 12344 t = parent.predicate("fhir:"+parentType+'.'+name); 12345 } 12346 composeBackboneElement(t, "param", name, element, index); 12347 if (element.hasNameElement()) 12348 composeString(t, "TestScript", "name", element.getNameElement(), -1); 12349 if (element.hasValueElement()) 12350 composeString(t, "TestScript", "value", element.getValueElement(), -1); 12351 } 12352 12353 protected void composeTestScriptTestScriptRulesetComponent(Complex parent, String parentType, String name, TestScript.TestScriptRulesetComponent element, int index) { 12354 if (element == null) 12355 return; 12356 Complex t; 12357 if (Utilities.noString(parentType)) 12358 t = parent; 12359 else { 12360 t = parent.predicate("fhir:"+parentType+'.'+name); 12361 } 12362 composeBackboneElement(t, "ruleset", name, element, index); 12363 if (element.hasResource()) 12364 composeReference(t, "TestScript", "resource", element.getResource(), -1); 12365 for (int i = 0; i < element.getRule().size(); i++) 12366 composeTestScriptRulesetRuleComponent(t, "TestScript", "rule", element.getRule().get(i), i); 12367 } 12368 12369 protected void composeTestScriptRulesetRuleComponent(Complex parent, String parentType, String name, TestScript.RulesetRuleComponent element, int index) { 12370 if (element == null) 12371 return; 12372 Complex t; 12373 if (Utilities.noString(parentType)) 12374 t = parent; 12375 else { 12376 t = parent.predicate("fhir:"+parentType+'.'+name); 12377 } 12378 composeBackboneElement(t, "rule", name, element, index); 12379 if (element.hasRuleIdElement()) 12380 composeId(t, "TestScript", "ruleId", element.getRuleIdElement(), -1); 12381 for (int i = 0; i < element.getParam().size(); i++) 12382 composeTestScriptRulesetRuleParamComponent(t, "TestScript", "param", element.getParam().get(i), i); 12383 } 12384 12385 protected void composeTestScriptRulesetRuleParamComponent(Complex parent, String parentType, String name, TestScript.RulesetRuleParamComponent element, int index) { 12386 if (element == null) 12387 return; 12388 Complex t; 12389 if (Utilities.noString(parentType)) 12390 t = parent; 12391 else { 12392 t = parent.predicate("fhir:"+parentType+'.'+name); 12393 } 12394 composeBackboneElement(t, "param", name, element, index); 12395 if (element.hasNameElement()) 12396 composeString(t, "TestScript", "name", element.getNameElement(), -1); 12397 if (element.hasValueElement()) 12398 composeString(t, "TestScript", "value", element.getValueElement(), -1); 12399 } 12400 12401 protected void composeTestScriptTestScriptSetupComponent(Complex parent, String parentType, String name, TestScript.TestScriptSetupComponent element, int index) { 12402 if (element == null) 12403 return; 12404 Complex t; 12405 if (Utilities.noString(parentType)) 12406 t = parent; 12407 else { 12408 t = parent.predicate("fhir:"+parentType+'.'+name); 12409 } 12410 composeBackboneElement(t, "setup", name, element, index); 12411 for (int i = 0; i < element.getAction().size(); i++) 12412 composeTestScriptSetupActionComponent(t, "TestScript", "action", element.getAction().get(i), i); 12413 } 12414 12415 protected void composeTestScriptSetupActionComponent(Complex parent, String parentType, String name, TestScript.SetupActionComponent element, int index) { 12416 if (element == null) 12417 return; 12418 Complex t; 12419 if (Utilities.noString(parentType)) 12420 t = parent; 12421 else { 12422 t = parent.predicate("fhir:"+parentType+'.'+name); 12423 } 12424 composeBackboneElement(t, "action", name, element, index); 12425 if (element.hasOperation()) 12426 composeTestScriptSetupActionOperationComponent(t, "TestScript", "operation", element.getOperation(), -1); 12427 if (element.hasAssert()) 12428 composeTestScriptSetupActionAssertComponent(t, "TestScript", "assert", element.getAssert(), -1); 12429 } 12430 12431 protected void composeTestScriptSetupActionOperationComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationComponent element, int index) { 12432 if (element == null) 12433 return; 12434 Complex t; 12435 if (Utilities.noString(parentType)) 12436 t = parent; 12437 else { 12438 t = parent.predicate("fhir:"+parentType+'.'+name); 12439 } 12440 composeBackboneElement(t, "operation", name, element, index); 12441 if (element.hasType()) 12442 composeCoding(t, "TestScript", "type", element.getType(), -1); 12443 if (element.hasResourceElement()) 12444 composeCode(t, "TestScript", "resource", element.getResourceElement(), -1); 12445 if (element.hasLabelElement()) 12446 composeString(t, "TestScript", "label", element.getLabelElement(), -1); 12447 if (element.hasDescriptionElement()) 12448 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 12449 if (element.hasAcceptElement()) 12450 composeEnum(t, "TestScript", "accept", element.getAcceptElement(), -1); 12451 if (element.hasContentTypeElement()) 12452 composeEnum(t, "TestScript", "contentType", element.getContentTypeElement(), -1); 12453 if (element.hasDestinationElement()) 12454 composeInteger(t, "TestScript", "destination", element.getDestinationElement(), -1); 12455 if (element.hasEncodeRequestUrlElement()) 12456 composeBoolean(t, "TestScript", "encodeRequestUrl", element.getEncodeRequestUrlElement(), -1); 12457 if (element.hasOriginElement()) 12458 composeInteger(t, "TestScript", "origin", element.getOriginElement(), -1); 12459 if (element.hasParamsElement()) 12460 composeString(t, "TestScript", "params", element.getParamsElement(), -1); 12461 for (int i = 0; i < element.getRequestHeader().size(); i++) 12462 composeTestScriptSetupActionOperationRequestHeaderComponent(t, "TestScript", "requestHeader", element.getRequestHeader().get(i), i); 12463 if (element.hasRequestIdElement()) 12464 composeId(t, "TestScript", "requestId", element.getRequestIdElement(), -1); 12465 if (element.hasResponseIdElement()) 12466 composeId(t, "TestScript", "responseId", element.getResponseIdElement(), -1); 12467 if (element.hasSourceIdElement()) 12468 composeId(t, "TestScript", "sourceId", element.getSourceIdElement(), -1); 12469 if (element.hasTargetIdElement()) 12470 composeId(t, "TestScript", "targetId", element.getTargetIdElement(), -1); 12471 if (element.hasUrlElement()) 12472 composeString(t, "TestScript", "url", element.getUrlElement(), -1); 12473 } 12474 12475 protected void composeTestScriptSetupActionOperationRequestHeaderComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationRequestHeaderComponent element, int index) { 12476 if (element == null) 12477 return; 12478 Complex t; 12479 if (Utilities.noString(parentType)) 12480 t = parent; 12481 else { 12482 t = parent.predicate("fhir:"+parentType+'.'+name); 12483 } 12484 composeBackboneElement(t, "requestHeader", name, element, index); 12485 if (element.hasFieldElement()) 12486 composeString(t, "TestScript", "field", element.getFieldElement(), -1); 12487 if (element.hasValueElement()) 12488 composeString(t, "TestScript", "value", element.getValueElement(), -1); 12489 } 12490 12491 protected void composeTestScriptSetupActionAssertComponent(Complex parent, String parentType, String name, TestScript.SetupActionAssertComponent element, int index) { 12492 if (element == null) 12493 return; 12494 Complex t; 12495 if (Utilities.noString(parentType)) 12496 t = parent; 12497 else { 12498 t = parent.predicate("fhir:"+parentType+'.'+name); 12499 } 12500 composeBackboneElement(t, "assert", name, element, index); 12501 if (element.hasLabelElement()) 12502 composeString(t, "TestScript", "label", element.getLabelElement(), -1); 12503 if (element.hasDescriptionElement()) 12504 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 12505 if (element.hasDirectionElement()) 12506 composeEnum(t, "TestScript", "direction", element.getDirectionElement(), -1); 12507 if (element.hasCompareToSourceIdElement()) 12508 composeString(t, "TestScript", "compareToSourceId", element.getCompareToSourceIdElement(), -1); 12509 if (element.hasCompareToSourceExpressionElement()) 12510 composeString(t, "TestScript", "compareToSourceExpression", element.getCompareToSourceExpressionElement(), -1); 12511 if (element.hasCompareToSourcePathElement()) 12512 composeString(t, "TestScript", "compareToSourcePath", element.getCompareToSourcePathElement(), -1); 12513 if (element.hasContentTypeElement()) 12514 composeEnum(t, "TestScript", "contentType", element.getContentTypeElement(), -1); 12515 if (element.hasExpressionElement()) 12516 composeString(t, "TestScript", "expression", element.getExpressionElement(), -1); 12517 if (element.hasHeaderFieldElement()) 12518 composeString(t, "TestScript", "headerField", element.getHeaderFieldElement(), -1); 12519 if (element.hasMinimumIdElement()) 12520 composeString(t, "TestScript", "minimumId", element.getMinimumIdElement(), -1); 12521 if (element.hasNavigationLinksElement()) 12522 composeBoolean(t, "TestScript", "navigationLinks", element.getNavigationLinksElement(), -1); 12523 if (element.hasOperatorElement()) 12524 composeEnum(t, "TestScript", "operator", element.getOperatorElement(), -1); 12525 if (element.hasPathElement()) 12526 composeString(t, "TestScript", "path", element.getPathElement(), -1); 12527 if (element.hasRequestMethodElement()) 12528 composeEnum(t, "TestScript", "requestMethod", element.getRequestMethodElement(), -1); 12529 if (element.hasRequestURLElement()) 12530 composeString(t, "TestScript", "requestURL", element.getRequestURLElement(), -1); 12531 if (element.hasResourceElement()) 12532 composeCode(t, "TestScript", "resource", element.getResourceElement(), -1); 12533 if (element.hasResponseElement()) 12534 composeEnum(t, "TestScript", "response", element.getResponseElement(), -1); 12535 if (element.hasResponseCodeElement()) 12536 composeString(t, "TestScript", "responseCode", element.getResponseCodeElement(), -1); 12537 if (element.hasRule()) 12538 composeTestScriptActionAssertRuleComponent(t, "TestScript", "rule", element.getRule(), -1); 12539 if (element.hasRuleset()) 12540 composeTestScriptActionAssertRulesetComponent(t, "TestScript", "ruleset", element.getRuleset(), -1); 12541 if (element.hasSourceIdElement()) 12542 composeId(t, "TestScript", "sourceId", element.getSourceIdElement(), -1); 12543 if (element.hasValidateProfileIdElement()) 12544 composeId(t, "TestScript", "validateProfileId", element.getValidateProfileIdElement(), -1); 12545 if (element.hasValueElement()) 12546 composeString(t, "TestScript", "value", element.getValueElement(), -1); 12547 if (element.hasWarningOnlyElement()) 12548 composeBoolean(t, "TestScript", "warningOnly", element.getWarningOnlyElement(), -1); 12549 } 12550 12551 protected void composeTestScriptActionAssertRuleComponent(Complex parent, String parentType, String name, TestScript.ActionAssertRuleComponent element, int index) { 12552 if (element == null) 12553 return; 12554 Complex t; 12555 if (Utilities.noString(parentType)) 12556 t = parent; 12557 else { 12558 t = parent.predicate("fhir:"+parentType+'.'+name); 12559 } 12560 composeBackboneElement(t, "rule", name, element, index); 12561 if (element.hasRuleIdElement()) 12562 composeId(t, "TestScript", "ruleId", element.getRuleIdElement(), -1); 12563 for (int i = 0; i < element.getParam().size(); i++) 12564 composeTestScriptActionAssertRuleParamComponent(t, "TestScript", "param", element.getParam().get(i), i); 12565 } 12566 12567 protected void composeTestScriptActionAssertRuleParamComponent(Complex parent, String parentType, String name, TestScript.ActionAssertRuleParamComponent element, int index) { 12568 if (element == null) 12569 return; 12570 Complex t; 12571 if (Utilities.noString(parentType)) 12572 t = parent; 12573 else { 12574 t = parent.predicate("fhir:"+parentType+'.'+name); 12575 } 12576 composeBackboneElement(t, "param", name, element, index); 12577 if (element.hasNameElement()) 12578 composeString(t, "TestScript", "name", element.getNameElement(), -1); 12579 if (element.hasValueElement()) 12580 composeString(t, "TestScript", "value", element.getValueElement(), -1); 12581 } 12582 12583 protected void composeTestScriptActionAssertRulesetComponent(Complex parent, String parentType, String name, TestScript.ActionAssertRulesetComponent element, int index) { 12584 if (element == null) 12585 return; 12586 Complex t; 12587 if (Utilities.noString(parentType)) 12588 t = parent; 12589 else { 12590 t = parent.predicate("fhir:"+parentType+'.'+name); 12591 } 12592 composeBackboneElement(t, "ruleset", name, element, index); 12593 if (element.hasRulesetIdElement()) 12594 composeId(t, "TestScript", "rulesetId", element.getRulesetIdElement(), -1); 12595 for (int i = 0; i < element.getRule().size(); i++) 12596 composeTestScriptActionAssertRulesetRuleComponent(t, "TestScript", "rule", element.getRule().get(i), i); 12597 } 12598 12599 protected void composeTestScriptActionAssertRulesetRuleComponent(Complex parent, String parentType, String name, TestScript.ActionAssertRulesetRuleComponent element, int index) { 12600 if (element == null) 12601 return; 12602 Complex t; 12603 if (Utilities.noString(parentType)) 12604 t = parent; 12605 else { 12606 t = parent.predicate("fhir:"+parentType+'.'+name); 12607 } 12608 composeBackboneElement(t, "rule", name, element, index); 12609 if (element.hasRuleIdElement()) 12610 composeId(t, "TestScript", "ruleId", element.getRuleIdElement(), -1); 12611 for (int i = 0; i < element.getParam().size(); i++) 12612 composeTestScriptActionAssertRulesetRuleParamComponent(t, "TestScript", "param", element.getParam().get(i), i); 12613 } 12614 12615 protected void composeTestScriptActionAssertRulesetRuleParamComponent(Complex parent, String parentType, String name, TestScript.ActionAssertRulesetRuleParamComponent element, int index) { 12616 if (element == null) 12617 return; 12618 Complex t; 12619 if (Utilities.noString(parentType)) 12620 t = parent; 12621 else { 12622 t = parent.predicate("fhir:"+parentType+'.'+name); 12623 } 12624 composeBackboneElement(t, "param", name, element, index); 12625 if (element.hasNameElement()) 12626 composeString(t, "TestScript", "name", element.getNameElement(), -1); 12627 if (element.hasValueElement()) 12628 composeString(t, "TestScript", "value", element.getValueElement(), -1); 12629 } 12630 12631 protected void composeTestScriptTestScriptTestComponent(Complex parent, String parentType, String name, TestScript.TestScriptTestComponent element, int index) { 12632 if (element == null) 12633 return; 12634 Complex t; 12635 if (Utilities.noString(parentType)) 12636 t = parent; 12637 else { 12638 t = parent.predicate("fhir:"+parentType+'.'+name); 12639 } 12640 composeBackboneElement(t, "test", name, element, index); 12641 if (element.hasNameElement()) 12642 composeString(t, "TestScript", "name", element.getNameElement(), -1); 12643 if (element.hasDescriptionElement()) 12644 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 12645 for (int i = 0; i < element.getAction().size(); i++) 12646 composeTestScriptTestActionComponent(t, "TestScript", "action", element.getAction().get(i), i); 12647 } 12648 12649 protected void composeTestScriptTestActionComponent(Complex parent, String parentType, String name, TestScript.TestActionComponent element, int index) { 12650 if (element == null) 12651 return; 12652 Complex t; 12653 if (Utilities.noString(parentType)) 12654 t = parent; 12655 else { 12656 t = parent.predicate("fhir:"+parentType+'.'+name); 12657 } 12658 composeBackboneElement(t, "action", name, element, index); 12659 if (element.hasOperation()) 12660 composeTestScriptSetupActionOperationComponent(t, "TestScript", "operation", element.getOperation(), -1); 12661 if (element.hasAssert()) 12662 composeTestScriptSetupActionAssertComponent(t, "TestScript", "assert", element.getAssert(), -1); 12663 } 12664 12665 protected void composeTestScriptTestScriptTeardownComponent(Complex parent, String parentType, String name, TestScript.TestScriptTeardownComponent element, int index) { 12666 if (element == null) 12667 return; 12668 Complex t; 12669 if (Utilities.noString(parentType)) 12670 t = parent; 12671 else { 12672 t = parent.predicate("fhir:"+parentType+'.'+name); 12673 } 12674 composeBackboneElement(t, "teardown", name, element, index); 12675 for (int i = 0; i < element.getAction().size(); i++) 12676 composeTestScriptTeardownActionComponent(t, "TestScript", "action", element.getAction().get(i), i); 12677 } 12678 12679 protected void composeTestScriptTeardownActionComponent(Complex parent, String parentType, String name, TestScript.TeardownActionComponent element, int index) { 12680 if (element == null) 12681 return; 12682 Complex t; 12683 if (Utilities.noString(parentType)) 12684 t = parent; 12685 else { 12686 t = parent.predicate("fhir:"+parentType+'.'+name); 12687 } 12688 composeBackboneElement(t, "action", name, element, index); 12689 if (element.hasOperation()) 12690 composeTestScriptSetupActionOperationComponent(t, "TestScript", "operation", element.getOperation(), -1); 12691 } 12692 12693 protected void composeValueSet(Complex parent, String parentType, String name, ValueSet element, int index) { 12694 if (element == null) 12695 return; 12696 Complex t; 12697 if (Utilities.noString(parentType)) 12698 t = parent; 12699 else { 12700 t = parent.predicate("fhir:"+parentType+'.'+name); 12701 } 12702 composeDomainResource(t, "ValueSet", name, element, index); 12703 if (element.hasUrlElement()) 12704 composeUri(t, "ValueSet", "url", element.getUrlElement(), -1); 12705 for (int i = 0; i < element.getIdentifier().size(); i++) 12706 composeIdentifier(t, "ValueSet", "identifier", element.getIdentifier().get(i), i); 12707 if (element.hasVersionElement()) 12708 composeString(t, "ValueSet", "version", element.getVersionElement(), -1); 12709 if (element.hasNameElement()) 12710 composeString(t, "ValueSet", "name", element.getNameElement(), -1); 12711 if (element.hasTitleElement()) 12712 composeString(t, "ValueSet", "title", element.getTitleElement(), -1); 12713 if (element.hasStatusElement()) 12714 composeEnum(t, "ValueSet", "status", element.getStatusElement(), -1); 12715 if (element.hasExperimentalElement()) 12716 composeBoolean(t, "ValueSet", "experimental", element.getExperimentalElement(), -1); 12717 if (element.hasDateElement()) 12718 composeDateTime(t, "ValueSet", "date", element.getDateElement(), -1); 12719 if (element.hasPublisherElement()) 12720 composeString(t, "ValueSet", "publisher", element.getPublisherElement(), -1); 12721 for (int i = 0; i < element.getContact().size(); i++) 12722 composeContactDetail(t, "ValueSet", "contact", element.getContact().get(i), i); 12723 if (element.hasDescriptionElement()) 12724 composeMarkdown(t, "ValueSet", "description", element.getDescriptionElement(), -1); 12725 for (int i = 0; i < element.getUseContext().size(); i++) 12726 composeUsageContext(t, "ValueSet", "useContext", element.getUseContext().get(i), i); 12727 for (int i = 0; i < element.getJurisdiction().size(); i++) 12728 composeCodeableConcept(t, "ValueSet", "jurisdiction", element.getJurisdiction().get(i), i); 12729 if (element.hasImmutableElement()) 12730 composeBoolean(t, "ValueSet", "immutable", element.getImmutableElement(), -1); 12731 if (element.hasPurposeElement()) 12732 composeMarkdown(t, "ValueSet", "purpose", element.getPurposeElement(), -1); 12733 if (element.hasCopyrightElement()) 12734 composeMarkdown(t, "ValueSet", "copyright", element.getCopyrightElement(), -1); 12735 if (element.hasExtensibleElement()) 12736 composeBoolean(t, "ValueSet", "extensible", element.getExtensibleElement(), -1); 12737 if (element.hasCompose()) 12738 composeValueSetValueSetComposeComponent(t, "ValueSet", "compose", element.getCompose(), -1); 12739 if (element.hasExpansion()) 12740 composeValueSetValueSetExpansionComponent(t, "ValueSet", "expansion", element.getExpansion(), -1); 12741 } 12742 12743 protected void composeValueSetValueSetComposeComponent(Complex parent, String parentType, String name, ValueSet.ValueSetComposeComponent element, int index) { 12744 if (element == null) 12745 return; 12746 Complex t; 12747 if (Utilities.noString(parentType)) 12748 t = parent; 12749 else { 12750 t = parent.predicate("fhir:"+parentType+'.'+name); 12751 } 12752 composeBackboneElement(t, "compose", name, element, index); 12753 if (element.hasLockedDateElement()) 12754 composeDate(t, "ValueSet", "lockedDate", element.getLockedDateElement(), -1); 12755 if (element.hasInactiveElement()) 12756 composeBoolean(t, "ValueSet", "inactive", element.getInactiveElement(), -1); 12757 for (int i = 0; i < element.getInclude().size(); i++) 12758 composeValueSetConceptSetComponent(t, "ValueSet", "include", element.getInclude().get(i), i); 12759 for (int i = 0; i < element.getExclude().size(); i++) 12760 composeValueSetConceptSetComponent(t, "ValueSet", "exclude", element.getExclude().get(i), i); 12761 } 12762 12763 protected void composeValueSetConceptSetComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetComponent 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, "include", name, element, index); 12773 if (element.hasSystemElement()) 12774 composeUri(t, "ValueSet", "system", element.getSystemElement(), -1); 12775 if (element.hasVersionElement()) 12776 composeString(t, "ValueSet", "version", element.getVersionElement(), -1); 12777 for (int i = 0; i < element.getConcept().size(); i++) 12778 composeValueSetConceptReferenceComponent(t, "ValueSet", "concept", element.getConcept().get(i), i); 12779 for (int i = 0; i < element.getFilter().size(); i++) 12780 composeValueSetConceptSetFilterComponent(t, "ValueSet", "filter", element.getFilter().get(i), i); 12781 for (int i = 0; i < element.getValueSet().size(); i++) 12782 composeUri(t, "ValueSet", "valueSet", element.getValueSet().get(i), i); 12783 } 12784 12785 protected void composeValueSetConceptReferenceComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceComponent element, int index) { 12786 if (element == null) 12787 return; 12788 Complex t; 12789 if (Utilities.noString(parentType)) 12790 t = parent; 12791 else { 12792 t = parent.predicate("fhir:"+parentType+'.'+name); 12793 } 12794 composeBackboneElement(t, "concept", name, element, index); 12795 if (element.hasCodeElement()) 12796 composeCode(t, "ValueSet", "code", element.getCodeElement(), -1); 12797 if (element.hasDisplayElement()) 12798 composeString(t, "ValueSet", "display", element.getDisplayElement(), -1); 12799 for (int i = 0; i < element.getDesignation().size(); i++) 12800 composeValueSetConceptReferenceDesignationComponent(t, "ValueSet", "designation", element.getDesignation().get(i), i); 12801 } 12802 12803 protected void composeValueSetConceptReferenceDesignationComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceDesignationComponent element, int index) { 12804 if (element == null) 12805 return; 12806 Complex t; 12807 if (Utilities.noString(parentType)) 12808 t = parent; 12809 else { 12810 t = parent.predicate("fhir:"+parentType+'.'+name); 12811 } 12812 composeBackboneElement(t, "designation", name, element, index); 12813 if (element.hasLanguageElement()) 12814 composeCode(t, "ValueSet", "language", element.getLanguageElement(), -1); 12815 if (element.hasUse()) 12816 composeCoding(t, "ValueSet", "use", element.getUse(), -1); 12817 if (element.hasValueElement()) 12818 composeString(t, "ValueSet", "value", element.getValueElement(), -1); 12819 } 12820 12821 protected void composeValueSetConceptSetFilterComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetFilterComponent element, int index) { 12822 if (element == null) 12823 return; 12824 Complex t; 12825 if (Utilities.noString(parentType)) 12826 t = parent; 12827 else { 12828 t = parent.predicate("fhir:"+parentType+'.'+name); 12829 } 12830 composeBackboneElement(t, "filter", name, element, index); 12831 if (element.hasPropertyElement()) 12832 composeCode(t, "ValueSet", "property", element.getPropertyElement(), -1); 12833 if (element.hasOpElement()) 12834 composeEnum(t, "ValueSet", "op", element.getOpElement(), -1); 12835 if (element.hasValueElement()) 12836 composeCode(t, "ValueSet", "value", element.getValueElement(), -1); 12837 } 12838 12839 protected void composeValueSetValueSetExpansionComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionComponent element, int index) { 12840 if (element == null) 12841 return; 12842 Complex t; 12843 if (Utilities.noString(parentType)) 12844 t = parent; 12845 else { 12846 t = parent.predicate("fhir:"+parentType+'.'+name); 12847 } 12848 composeBackboneElement(t, "expansion", name, element, index); 12849 if (element.hasIdentifierElement()) 12850 composeUri(t, "ValueSet", "identifier", element.getIdentifierElement(), -1); 12851 if (element.hasTimestampElement()) 12852 composeDateTime(t, "ValueSet", "timestamp", element.getTimestampElement(), -1); 12853 if (element.hasTotalElement()) 12854 composeInteger(t, "ValueSet", "total", element.getTotalElement(), -1); 12855 if (element.hasOffsetElement()) 12856 composeInteger(t, "ValueSet", "offset", element.getOffsetElement(), -1); 12857 for (int i = 0; i < element.getParameter().size(); i++) 12858 composeValueSetValueSetExpansionParameterComponent(t, "ValueSet", "parameter", element.getParameter().get(i), i); 12859 for (int i = 0; i < element.getContains().size(); i++) 12860 composeValueSetValueSetExpansionContainsComponent(t, "ValueSet", "contains", element.getContains().get(i), i); 12861 } 12862 12863 protected void composeValueSetValueSetExpansionParameterComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionParameterComponent element, int index) { 12864 if (element == null) 12865 return; 12866 Complex t; 12867 if (Utilities.noString(parentType)) 12868 t = parent; 12869 else { 12870 t = parent.predicate("fhir:"+parentType+'.'+name); 12871 } 12872 composeBackboneElement(t, "parameter", name, element, index); 12873 if (element.hasNameElement()) 12874 composeString(t, "ValueSet", "name", element.getNameElement(), -1); 12875 if (element.hasValue()) 12876 composeType(t, "ValueSet", "value", element.getValue(), -1); 12877 } 12878 12879 protected void composeValueSetValueSetExpansionContainsComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionContainsComponent element, int index) { 12880 if (element == null) 12881 return; 12882 Complex t; 12883 if (Utilities.noString(parentType)) 12884 t = parent; 12885 else { 12886 t = parent.predicate("fhir:"+parentType+'.'+name); 12887 } 12888 composeBackboneElement(t, "contains", name, element, index); 12889 if (element.hasSystemElement()) 12890 composeUri(t, "ValueSet", "system", element.getSystemElement(), -1); 12891 if (element.hasAbstractElement()) 12892 composeBoolean(t, "ValueSet", "abstract", element.getAbstractElement(), -1); 12893 if (element.hasInactiveElement()) 12894 composeBoolean(t, "ValueSet", "inactive", element.getInactiveElement(), -1); 12895 if (element.hasVersionElement()) 12896 composeString(t, "ValueSet", "version", element.getVersionElement(), -1); 12897 if (element.hasCodeElement()) 12898 composeCode(t, "ValueSet", "code", element.getCodeElement(), -1); 12899 if (element.hasDisplayElement()) 12900 composeString(t, "ValueSet", "display", element.getDisplayElement(), -1); 12901 for (int i = 0; i < element.getDesignation().size(); i++) 12902 composeValueSetConceptReferenceDesignationComponent(t, "ValueSet", "designation", element.getDesignation().get(i), i); 12903 for (int i = 0; i < element.getContains().size(); i++) 12904 composeValueSetValueSetExpansionContainsComponent(t, "ValueSet", "contains", element.getContains().get(i), i); 12905 } 12906 12907 protected void composeVisionPrescription(Complex parent, String parentType, String name, VisionPrescription element, int index) { 12908 if (element == null) 12909 return; 12910 Complex t; 12911 if (Utilities.noString(parentType)) 12912 t = parent; 12913 else { 12914 t = parent.predicate("fhir:"+parentType+'.'+name); 12915 } 12916 composeDomainResource(t, "VisionPrescription", name, element, index); 12917 for (int i = 0; i < element.getIdentifier().size(); i++) 12918 composeIdentifier(t, "VisionPrescription", "identifier", element.getIdentifier().get(i), i); 12919 if (element.hasStatusElement()) 12920 composeEnum(t, "VisionPrescription", "status", element.getStatusElement(), -1); 12921 if (element.hasPatient()) 12922 composeReference(t, "VisionPrescription", "patient", element.getPatient(), -1); 12923 if (element.hasEncounter()) 12924 composeReference(t, "VisionPrescription", "encounter", element.getEncounter(), -1); 12925 if (element.hasDateWrittenElement()) 12926 composeDateTime(t, "VisionPrescription", "dateWritten", element.getDateWrittenElement(), -1); 12927 if (element.hasPrescriber()) 12928 composeReference(t, "VisionPrescription", "prescriber", element.getPrescriber(), -1); 12929 if (element.hasReason()) 12930 composeType(t, "VisionPrescription", "reason", element.getReason(), -1); 12931 for (int i = 0; i < element.getDispense().size(); i++) 12932 composeVisionPrescriptionVisionPrescriptionDispenseComponent(t, "VisionPrescription", "dispense", element.getDispense().get(i), i); 12933 } 12934 12935 protected void composeVisionPrescriptionVisionPrescriptionDispenseComponent(Complex parent, String parentType, String name, VisionPrescription.VisionPrescriptionDispenseComponent element, int index) { 12936 if (element == null) 12937 return; 12938 Complex t; 12939 if (Utilities.noString(parentType)) 12940 t = parent; 12941 else { 12942 t = parent.predicate("fhir:"+parentType+'.'+name); 12943 } 12944 composeBackboneElement(t, "dispense", name, element, index); 12945 if (element.hasProduct()) 12946 composeCodeableConcept(t, "VisionPrescription", "product", element.getProduct(), -1); 12947 if (element.hasEyeElement()) 12948 composeEnum(t, "VisionPrescription", "eye", element.getEyeElement(), -1); 12949 if (element.hasSphereElement()) 12950 composeDecimal(t, "VisionPrescription", "sphere", element.getSphereElement(), -1); 12951 if (element.hasCylinderElement()) 12952 composeDecimal(t, "VisionPrescription", "cylinder", element.getCylinderElement(), -1); 12953 if (element.hasAxisElement()) 12954 composeInteger(t, "VisionPrescription", "axis", element.getAxisElement(), -1); 12955 if (element.hasPrismElement()) 12956 composeDecimal(t, "VisionPrescription", "prism", element.getPrismElement(), -1); 12957 if (element.hasBaseElement()) 12958 composeEnum(t, "VisionPrescription", "base", element.getBaseElement(), -1); 12959 if (element.hasAddElement()) 12960 composeDecimal(t, "VisionPrescription", "add", element.getAddElement(), -1); 12961 if (element.hasPowerElement()) 12962 composeDecimal(t, "VisionPrescription", "power", element.getPowerElement(), -1); 12963 if (element.hasBackCurveElement()) 12964 composeDecimal(t, "VisionPrescription", "backCurve", element.getBackCurveElement(), -1); 12965 if (element.hasDiameterElement()) 12966 composeDecimal(t, "VisionPrescription", "diameter", element.getDiameterElement(), -1); 12967 if (element.hasDuration()) 12968 composeQuantity(t, "VisionPrescription", "duration", element.getDuration(), -1); 12969 if (element.hasColorElement()) 12970 composeString(t, "VisionPrescription", "color", element.getColorElement(), -1); 12971 if (element.hasBrandElement()) 12972 composeString(t, "VisionPrescription", "brand", element.getBrandElement(), -1); 12973 for (int i = 0; i < element.getNote().size(); i++) 12974 composeAnnotation(t, "VisionPrescription", "note", element.getNote().get(i), i); 12975 } 12976 12977 @Override 12978 protected void composeResource(Complex parent, Resource resource) { 12979 if (resource instanceof Parameters) 12980 composeParameters(parent, null, "Parameters", (Parameters)resource, -1); 12981 else if (resource instanceof Account) 12982 composeAccount(parent, null, "Account", (Account)resource, -1); 12983 else if (resource instanceof ActivityDefinition) 12984 composeActivityDefinition(parent, null, "ActivityDefinition", (ActivityDefinition)resource, -1); 12985 else if (resource instanceof AdverseEvent) 12986 composeAdverseEvent(parent, null, "AdverseEvent", (AdverseEvent)resource, -1); 12987 else if (resource instanceof AllergyIntolerance) 12988 composeAllergyIntolerance(parent, null, "AllergyIntolerance", (AllergyIntolerance)resource, -1); 12989 else if (resource instanceof Appointment) 12990 composeAppointment(parent, null, "Appointment", (Appointment)resource, -1); 12991 else if (resource instanceof AppointmentResponse) 12992 composeAppointmentResponse(parent, null, "AppointmentResponse", (AppointmentResponse)resource, -1); 12993 else if (resource instanceof AuditEvent) 12994 composeAuditEvent(parent, null, "AuditEvent", (AuditEvent)resource, -1); 12995 else if (resource instanceof Basic) 12996 composeBasic(parent, null, "Basic", (Basic)resource, -1); 12997 else if (resource instanceof Binary) 12998 composeBinary(parent, null, "Binary", (Binary)resource, -1); 12999 else if (resource instanceof BodySite) 13000 composeBodySite(parent, null, "BodySite", (BodySite)resource, -1); 13001 else if (resource instanceof Bundle) 13002 composeBundle(parent, null, "Bundle", (Bundle)resource, -1); 13003 else if (resource instanceof CapabilityStatement) 13004 composeCapabilityStatement(parent, null, "CapabilityStatement", (CapabilityStatement)resource, -1); 13005 else if (resource instanceof CarePlan) 13006 composeCarePlan(parent, null, "CarePlan", (CarePlan)resource, -1); 13007 else if (resource instanceof CareTeam) 13008 composeCareTeam(parent, null, "CareTeam", (CareTeam)resource, -1); 13009 else if (resource instanceof ChargeItem) 13010 composeChargeItem(parent, null, "ChargeItem", (ChargeItem)resource, -1); 13011 else if (resource instanceof Claim) 13012 composeClaim(parent, null, "Claim", (Claim)resource, -1); 13013 else if (resource instanceof ClaimResponse) 13014 composeClaimResponse(parent, null, "ClaimResponse", (ClaimResponse)resource, -1); 13015 else if (resource instanceof ClinicalImpression) 13016 composeClinicalImpression(parent, null, "ClinicalImpression", (ClinicalImpression)resource, -1); 13017 else if (resource instanceof CodeSystem) 13018 composeCodeSystem(parent, null, "CodeSystem", (CodeSystem)resource, -1); 13019 else if (resource instanceof Communication) 13020 composeCommunication(parent, null, "Communication", (Communication)resource, -1); 13021 else if (resource instanceof CommunicationRequest) 13022 composeCommunicationRequest(parent, null, "CommunicationRequest", (CommunicationRequest)resource, -1); 13023 else if (resource instanceof CompartmentDefinition) 13024 composeCompartmentDefinition(parent, null, "CompartmentDefinition", (CompartmentDefinition)resource, -1); 13025 else if (resource instanceof Composition) 13026 composeComposition(parent, null, "Composition", (Composition)resource, -1); 13027 else if (resource instanceof ConceptMap) 13028 composeConceptMap(parent, null, "ConceptMap", (ConceptMap)resource, -1); 13029 else if (resource instanceof Condition) 13030 composeCondition(parent, null, "Condition", (Condition)resource, -1); 13031 else if (resource instanceof Consent) 13032 composeConsent(parent, null, "Consent", (Consent)resource, -1); 13033 else if (resource instanceof Contract) 13034 composeContract(parent, null, "Contract", (Contract)resource, -1); 13035 else if (resource instanceof Coverage) 13036 composeCoverage(parent, null, "Coverage", (Coverage)resource, -1); 13037 else if (resource instanceof DataElement) 13038 composeDataElement(parent, null, "DataElement", (DataElement)resource, -1); 13039 else if (resource instanceof DetectedIssue) 13040 composeDetectedIssue(parent, null, "DetectedIssue", (DetectedIssue)resource, -1); 13041 else if (resource instanceof Device) 13042 composeDevice(parent, null, "Device", (Device)resource, -1); 13043 else if (resource instanceof DeviceComponent) 13044 composeDeviceComponent(parent, null, "DeviceComponent", (DeviceComponent)resource, -1); 13045 else if (resource instanceof DeviceMetric) 13046 composeDeviceMetric(parent, null, "DeviceMetric", (DeviceMetric)resource, -1); 13047 else if (resource instanceof DeviceRequest) 13048 composeDeviceRequest(parent, null, "DeviceRequest", (DeviceRequest)resource, -1); 13049 else if (resource instanceof DeviceUseStatement) 13050 composeDeviceUseStatement(parent, null, "DeviceUseStatement", (DeviceUseStatement)resource, -1); 13051 else if (resource instanceof DiagnosticReport) 13052 composeDiagnosticReport(parent, null, "DiagnosticReport", (DiagnosticReport)resource, -1); 13053 else if (resource instanceof DocumentManifest) 13054 composeDocumentManifest(parent, null, "DocumentManifest", (DocumentManifest)resource, -1); 13055 else if (resource instanceof DocumentReference) 13056 composeDocumentReference(parent, null, "DocumentReference", (DocumentReference)resource, -1); 13057 else if (resource instanceof EligibilityRequest) 13058 composeEligibilityRequest(parent, null, "EligibilityRequest", (EligibilityRequest)resource, -1); 13059 else if (resource instanceof EligibilityResponse) 13060 composeEligibilityResponse(parent, null, "EligibilityResponse", (EligibilityResponse)resource, -1); 13061 else if (resource instanceof Encounter) 13062 composeEncounter(parent, null, "Encounter", (Encounter)resource, -1); 13063 else if (resource instanceof Endpoint) 13064 composeEndpoint(parent, null, "Endpoint", (Endpoint)resource, -1); 13065 else if (resource instanceof EnrollmentRequest) 13066 composeEnrollmentRequest(parent, null, "EnrollmentRequest", (EnrollmentRequest)resource, -1); 13067 else if (resource instanceof EnrollmentResponse) 13068 composeEnrollmentResponse(parent, null, "EnrollmentResponse", (EnrollmentResponse)resource, -1); 13069 else if (resource instanceof EpisodeOfCare) 13070 composeEpisodeOfCare(parent, null, "EpisodeOfCare", (EpisodeOfCare)resource, -1); 13071 else if (resource instanceof ExpansionProfile) 13072 composeExpansionProfile(parent, null, "ExpansionProfile", (ExpansionProfile)resource, -1); 13073 else if (resource instanceof ExplanationOfBenefit) 13074 composeExplanationOfBenefit(parent, null, "ExplanationOfBenefit", (ExplanationOfBenefit)resource, -1); 13075 else if (resource instanceof FamilyMemberHistory) 13076 composeFamilyMemberHistory(parent, null, "FamilyMemberHistory", (FamilyMemberHistory)resource, -1); 13077 else if (resource instanceof Flag) 13078 composeFlag(parent, null, "Flag", (Flag)resource, -1); 13079 else if (resource instanceof Goal) 13080 composeGoal(parent, null, "Goal", (Goal)resource, -1); 13081 else if (resource instanceof GraphDefinition) 13082 composeGraphDefinition(parent, null, "GraphDefinition", (GraphDefinition)resource, -1); 13083 else if (resource instanceof Group) 13084 composeGroup(parent, null, "Group", (Group)resource, -1); 13085 else if (resource instanceof GuidanceResponse) 13086 composeGuidanceResponse(parent, null, "GuidanceResponse", (GuidanceResponse)resource, -1); 13087 else if (resource instanceof HealthcareService) 13088 composeHealthcareService(parent, null, "HealthcareService", (HealthcareService)resource, -1); 13089 else if (resource instanceof ImagingManifest) 13090 composeImagingManifest(parent, null, "ImagingManifest", (ImagingManifest)resource, -1); 13091 else if (resource instanceof ImagingStudy) 13092 composeImagingStudy(parent, null, "ImagingStudy", (ImagingStudy)resource, -1); 13093 else if (resource instanceof Immunization) 13094 composeImmunization(parent, null, "Immunization", (Immunization)resource, -1); 13095 else if (resource instanceof ImmunizationRecommendation) 13096 composeImmunizationRecommendation(parent, null, "ImmunizationRecommendation", (ImmunizationRecommendation)resource, -1); 13097 else if (resource instanceof ImplementationGuide) 13098 composeImplementationGuide(parent, null, "ImplementationGuide", (ImplementationGuide)resource, -1); 13099 else if (resource instanceof Library) 13100 composeLibrary(parent, null, "Library", (Library)resource, -1); 13101 else if (resource instanceof Linkage) 13102 composeLinkage(parent, null, "Linkage", (Linkage)resource, -1); 13103 else if (resource instanceof ListResource) 13104 composeListResource(parent, null, "ListResource", (ListResource)resource, -1); 13105 else if (resource instanceof Location) 13106 composeLocation(parent, null, "Location", (Location)resource, -1); 13107 else if (resource instanceof Measure) 13108 composeMeasure(parent, null, "Measure", (Measure)resource, -1); 13109 else if (resource instanceof MeasureReport) 13110 composeMeasureReport(parent, null, "MeasureReport", (MeasureReport)resource, -1); 13111 else if (resource instanceof Media) 13112 composeMedia(parent, null, "Media", (Media)resource, -1); 13113 else if (resource instanceof Medication) 13114 composeMedication(parent, null, "Medication", (Medication)resource, -1); 13115 else if (resource instanceof MedicationAdministration) 13116 composeMedicationAdministration(parent, null, "MedicationAdministration", (MedicationAdministration)resource, -1); 13117 else if (resource instanceof MedicationDispense) 13118 composeMedicationDispense(parent, null, "MedicationDispense", (MedicationDispense)resource, -1); 13119 else if (resource instanceof MedicationRequest) 13120 composeMedicationRequest(parent, null, "MedicationRequest", (MedicationRequest)resource, -1); 13121 else if (resource instanceof MedicationStatement) 13122 composeMedicationStatement(parent, null, "MedicationStatement", (MedicationStatement)resource, -1); 13123 else if (resource instanceof MessageDefinition) 13124 composeMessageDefinition(parent, null, "MessageDefinition", (MessageDefinition)resource, -1); 13125 else if (resource instanceof MessageHeader) 13126 composeMessageHeader(parent, null, "MessageHeader", (MessageHeader)resource, -1); 13127 else if (resource instanceof NamingSystem) 13128 composeNamingSystem(parent, null, "NamingSystem", (NamingSystem)resource, -1); 13129 else if (resource instanceof NutritionOrder) 13130 composeNutritionOrder(parent, null, "NutritionOrder", (NutritionOrder)resource, -1); 13131 else if (resource instanceof Observation) 13132 composeObservation(parent, null, "Observation", (Observation)resource, -1); 13133 else if (resource instanceof OperationDefinition) 13134 composeOperationDefinition(parent, null, "OperationDefinition", (OperationDefinition)resource, -1); 13135 else if (resource instanceof OperationOutcome) 13136 composeOperationOutcome(parent, null, "OperationOutcome", (OperationOutcome)resource, -1); 13137 else if (resource instanceof Organization) 13138 composeOrganization(parent, null, "Organization", (Organization)resource, -1); 13139 else if (resource instanceof Patient) 13140 composePatient(parent, null, "Patient", (Patient)resource, -1); 13141 else if (resource instanceof PaymentNotice) 13142 composePaymentNotice(parent, null, "PaymentNotice", (PaymentNotice)resource, -1); 13143 else if (resource instanceof PaymentReconciliation) 13144 composePaymentReconciliation(parent, null, "PaymentReconciliation", (PaymentReconciliation)resource, -1); 13145 else if (resource instanceof Person) 13146 composePerson(parent, null, "Person", (Person)resource, -1); 13147 else if (resource instanceof PlanDefinition) 13148 composePlanDefinition(parent, null, "PlanDefinition", (PlanDefinition)resource, -1); 13149 else if (resource instanceof Practitioner) 13150 composePractitioner(parent, null, "Practitioner", (Practitioner)resource, -1); 13151 else if (resource instanceof PractitionerRole) 13152 composePractitionerRole(parent, null, "PractitionerRole", (PractitionerRole)resource, -1); 13153 else if (resource instanceof Procedure) 13154 composeProcedure(parent, null, "Procedure", (Procedure)resource, -1); 13155 else if (resource instanceof ProcedureRequest) 13156 composeProcedureRequest(parent, null, "ProcedureRequest", (ProcedureRequest)resource, -1); 13157 else if (resource instanceof ProcessRequest) 13158 composeProcessRequest(parent, null, "ProcessRequest", (ProcessRequest)resource, -1); 13159 else if (resource instanceof ProcessResponse) 13160 composeProcessResponse(parent, null, "ProcessResponse", (ProcessResponse)resource, -1); 13161 else if (resource instanceof Provenance) 13162 composeProvenance(parent, null, "Provenance", (Provenance)resource, -1); 13163 else if (resource instanceof Questionnaire) 13164 composeQuestionnaire(parent, null, "Questionnaire", (Questionnaire)resource, -1); 13165 else if (resource instanceof QuestionnaireResponse) 13166 composeQuestionnaireResponse(parent, null, "QuestionnaireResponse", (QuestionnaireResponse)resource, -1); 13167 else if (resource instanceof ReferralRequest) 13168 composeReferralRequest(parent, null, "ReferralRequest", (ReferralRequest)resource, -1); 13169 else if (resource instanceof RelatedPerson) 13170 composeRelatedPerson(parent, null, "RelatedPerson", (RelatedPerson)resource, -1); 13171 else if (resource instanceof RequestGroup) 13172 composeRequestGroup(parent, null, "RequestGroup", (RequestGroup)resource, -1); 13173 else if (resource instanceof ResearchStudy) 13174 composeResearchStudy(parent, null, "ResearchStudy", (ResearchStudy)resource, -1); 13175 else if (resource instanceof ResearchSubject) 13176 composeResearchSubject(parent, null, "ResearchSubject", (ResearchSubject)resource, -1); 13177 else if (resource instanceof RiskAssessment) 13178 composeRiskAssessment(parent, null, "RiskAssessment", (RiskAssessment)resource, -1); 13179 else if (resource instanceof Schedule) 13180 composeSchedule(parent, null, "Schedule", (Schedule)resource, -1); 13181 else if (resource instanceof SearchParameter) 13182 composeSearchParameter(parent, null, "SearchParameter", (SearchParameter)resource, -1); 13183 else if (resource instanceof Sequence) 13184 composeSequence(parent, null, "Sequence", (Sequence)resource, -1); 13185 else if (resource instanceof ServiceDefinition) 13186 composeServiceDefinition(parent, null, "ServiceDefinition", (ServiceDefinition)resource, -1); 13187 else if (resource instanceof Slot) 13188 composeSlot(parent, null, "Slot", (Slot)resource, -1); 13189 else if (resource instanceof Specimen) 13190 composeSpecimen(parent, null, "Specimen", (Specimen)resource, -1); 13191 else if (resource instanceof StructureDefinition) 13192 composeStructureDefinition(parent, null, "StructureDefinition", (StructureDefinition)resource, -1); 13193 else if (resource instanceof StructureMap) 13194 composeStructureMap(parent, null, "StructureMap", (StructureMap)resource, -1); 13195 else if (resource instanceof Subscription) 13196 composeSubscription(parent, null, "Subscription", (Subscription)resource, -1); 13197 else if (resource instanceof Substance) 13198 composeSubstance(parent, null, "Substance", (Substance)resource, -1); 13199 else if (resource instanceof SupplyDelivery) 13200 composeSupplyDelivery(parent, null, "SupplyDelivery", (SupplyDelivery)resource, -1); 13201 else if (resource instanceof SupplyRequest) 13202 composeSupplyRequest(parent, null, "SupplyRequest", (SupplyRequest)resource, -1); 13203 else if (resource instanceof Task) 13204 composeTask(parent, null, "Task", (Task)resource, -1); 13205 else if (resource instanceof TestReport) 13206 composeTestReport(parent, null, "TestReport", (TestReport)resource, -1); 13207 else if (resource instanceof TestScript) 13208 composeTestScript(parent, null, "TestScript", (TestScript)resource, -1); 13209 else if (resource instanceof ValueSet) 13210 composeValueSet(parent, null, "ValueSet", (ValueSet)resource, -1); 13211 else if (resource instanceof VisionPrescription) 13212 composeVisionPrescription(parent, null, "VisionPrescription", (VisionPrescription)resource, -1); 13213 else 13214 throw new Error("Unhandled resource type "+resource.getClass().getName()); 13215 } 13216 13217 protected void composeType(Complex parent, String parentType, String name, Type value, int index) { 13218 if (value == null) 13219 return; 13220 else if (value instanceof DateType) 13221 composeDate(parent, parentType, name, (DateType)value, index); 13222 else if (value instanceof DateTimeType) 13223 composeDateTime(parent, parentType, name, (DateTimeType)value, index); 13224 else if (value instanceof CodeType) 13225 composeCode(parent, parentType, name, (CodeType)value, index); 13226 else if (value instanceof StringType) 13227 composeString(parent, parentType, name, (StringType)value, index); 13228 else if (value instanceof IntegerType) 13229 composeInteger(parent, parentType, name, (IntegerType)value, index); 13230 else if (value instanceof OidType) 13231 composeOid(parent, parentType, name, (OidType)value, index); 13232 else if (value instanceof UriType) 13233 composeUri(parent, parentType, name, (UriType)value, index); 13234 else if (value instanceof UuidType) 13235 composeUuid(parent, parentType, name, (UuidType)value, index); 13236 else if (value instanceof InstantType) 13237 composeInstant(parent, parentType, name, (InstantType)value, index); 13238 else if (value instanceof BooleanType) 13239 composeBoolean(parent, parentType, name, (BooleanType)value, index); 13240 else if (value instanceof Base64BinaryType) 13241 composeBase64Binary(parent, parentType, name, (Base64BinaryType)value, index); 13242 else if (value instanceof UnsignedIntType) 13243 composeUnsignedInt(parent, parentType, name, (UnsignedIntType)value, index); 13244 else if (value instanceof MarkdownType) 13245 composeMarkdown(parent, parentType, name, (MarkdownType)value, index); 13246 else if (value instanceof TimeType) 13247 composeTime(parent, parentType, name, (TimeType)value, index); 13248 else if (value instanceof IdType) 13249 composeId(parent, parentType, name, (IdType)value, index); 13250 else if (value instanceof PositiveIntType) 13251 composePositiveInt(parent, parentType, name, (PositiveIntType)value, index); 13252 else if (value instanceof DecimalType) 13253 composeDecimal(parent, parentType, name, (DecimalType)value, index); 13254 else if (value instanceof Extension) 13255 composeExtension(parent, parentType, name, (Extension)value, index); 13256 else if (value instanceof Narrative) 13257 composeNarrative(parent, parentType, name, (Narrative)value, index); 13258 else if (value instanceof Reference) 13259 composeReference(parent, parentType, name, (Reference)value, index); 13260 else if (value instanceof Quantity) 13261 composeQuantity(parent, parentType, name, (Quantity)value, index); 13262 else if (value instanceof Period) 13263 composePeriod(parent, parentType, name, (Period)value, index); 13264 else if (value instanceof Attachment) 13265 composeAttachment(parent, parentType, name, (Attachment)value, index); 13266 else if (value instanceof Duration) 13267 composeDuration(parent, parentType, name, (Duration)value, index); 13268 else if (value instanceof Count) 13269 composeCount(parent, parentType, name, (Count)value, index); 13270 else if (value instanceof Range) 13271 composeRange(parent, parentType, name, (Range)value, index); 13272 else if (value instanceof Annotation) 13273 composeAnnotation(parent, parentType, name, (Annotation)value, index); 13274 else if (value instanceof Money) 13275 composeMoney(parent, parentType, name, (Money)value, index); 13276 else if (value instanceof Identifier) 13277 composeIdentifier(parent, parentType, name, (Identifier)value, index); 13278 else if (value instanceof Coding) 13279 composeCoding(parent, parentType, name, (Coding)value, index); 13280 else if (value instanceof Signature) 13281 composeSignature(parent, parentType, name, (Signature)value, index); 13282 else if (value instanceof SampledData) 13283 composeSampledData(parent, parentType, name, (SampledData)value, index); 13284 else if (value instanceof Ratio) 13285 composeRatio(parent, parentType, name, (Ratio)value, index); 13286 else if (value instanceof Distance) 13287 composeDistance(parent, parentType, name, (Distance)value, index); 13288 else if (value instanceof Age) 13289 composeAge(parent, parentType, name, (Age)value, index); 13290 else if (value instanceof CodeableConcept) 13291 composeCodeableConcept(parent, parentType, name, (CodeableConcept)value, index); 13292 else if (value instanceof Meta) 13293 composeMeta(parent, parentType, name, (Meta)value, index); 13294 else if (value instanceof Address) 13295 composeAddress(parent, parentType, name, (Address)value, index); 13296 else if (value instanceof TriggerDefinition) 13297 composeTriggerDefinition(parent, parentType, name, (TriggerDefinition)value, index); 13298 else if (value instanceof Contributor) 13299 composeContributor(parent, parentType, name, (Contributor)value, index); 13300 else if (value instanceof DataRequirement) 13301 composeDataRequirement(parent, parentType, name, (DataRequirement)value, index); 13302 else if (value instanceof Dosage) 13303 composeDosage(parent, parentType, name, (Dosage)value, index); 13304 else if (value instanceof RelatedArtifact) 13305 composeRelatedArtifact(parent, parentType, name, (RelatedArtifact)value, index); 13306 else if (value instanceof ContactDetail) 13307 composeContactDetail(parent, parentType, name, (ContactDetail)value, index); 13308 else if (value instanceof HumanName) 13309 composeHumanName(parent, parentType, name, (HumanName)value, index); 13310 else if (value instanceof ContactPoint) 13311 composeContactPoint(parent, parentType, name, (ContactPoint)value, index); 13312 else if (value instanceof UsageContext) 13313 composeUsageContext(parent, parentType, name, (UsageContext)value, index); 13314 else if (value instanceof Timing) 13315 composeTiming(parent, parentType, name, (Timing)value, index); 13316 else if (value instanceof ElementDefinition) 13317 composeElementDefinition(parent, parentType, name, (ElementDefinition)value, index); 13318 else if (value instanceof ParameterDefinition) 13319 composeParameterDefinition(parent, parentType, name, (ParameterDefinition)value, index); 13320 else 13321 throw new Error("Unhandled type"); 13322 } 13323 13324}