001package org.hl7.fhir.dstu3.formats; 002 003 004 005 006/* 007 Copyright (c) 2011+, HL7, Inc. 008 All rights reserved. 009 010 Redistribution and use in source and binary forms, with or without modification, 011 are permitted provided that the following conditions are met: 012 013 * Redistributions of source code must retain the above copyright notice, this 014 list of conditions and the following disclaimer. 015 * Redistributions in binary form must reproduce the above copyright notice, 016 this list of conditions and the following disclaimer in the documentation 017 and/or other materials provided with the distribution. 018 * Neither the name of HL7 nor the names of its contributors may be used to 019 endorse or promote products derived from this software without specific 020 prior written permission. 021 022 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 023 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 024 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 025 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 026 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 027 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 028 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 029 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 030 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 031 POSSIBILITY OF SUCH DAMAGE. 032 033*/ 034 035// Generated on Mon, Apr 17, 2017 08:38+1000 for FHIR v3.0.x 036import org.hl7.fhir.dstu3.model.*; 037import org.hl7.fhir.dstu3.utils.formats.Turtle.Complex; 038import org.hl7.fhir.utilities.Utilities; 039 040public class RdfParser extends RdfParserBase { 041 042 public RdfParser() { 043 super(); 044 } 045 046 public RdfParser(boolean allowUnknownContent) { 047 super(); 048 setAllowUnknownContent(allowUnknownContent); 049 } 050 051 052 protected void composeElement(Complex t, String parentType, String name, Element element, int index) { 053 if (element == null) 054 return; 055 if (index > -1) 056 t.predicate("fhir:index", Integer.toString(index)); 057 if (element.hasIdElement()) 058 composeString(t, "Element", "id", element.getIdElement(), -1); 059 for (int i = 0; i < element.getExtension().size(); i++) 060 composeExtension(t, "Element", "extension", element.getExtension().get(i), i); 061 } 062 063 protected void composeBackboneElement(Complex t, String tType, String name, BackboneElement element, int index) { 064 composeElement(t, tType, name, element, index); 065 for (int i = 0; i < element.getModifierExtension().size(); i++) 066 composeExtension(t, "Element", "modifierExtension", element.getModifierExtension().get(i), i); 067 } 068 069 private void composeEnum(Complex parent, String parentType, String name, Enumeration<? extends Enum> value, int index) { 070 if (value == null) 071 return; 072 Complex t = parent.predicate("fhir:"+parentType+"."+name); 073 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 074 composeElement(t, parentType, name, value, index); 075 decorateCode(t, value); 076 } 077 078 079 protected void composeDate(Complex parent, String parentType, String name, DateType value, int index) { 080 if (value == null) 081 return; 082 Complex t = parent.predicate("fhir:"+parentType+"."+name); 083 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 084 composeElement(t, parentType, name, value, index); 085 } 086 087 protected void composeDateTime(Complex parent, String parentType, String name, DateTimeType value, int index) { 088 if (value == null) 089 return; 090 Complex t = parent.predicate("fhir:"+parentType+"."+name); 091 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 092 composeElement(t, parentType, name, value, index); 093 } 094 095 protected void composeCode(Complex parent, String parentType, String name, CodeType value, int index) { 096 if (value == null) 097 return; 098 Complex t = parent.predicate("fhir:"+parentType+"."+name); 099 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 100 composeElement(t, parentType, name, value, index); 101 decorateCode(t, value); 102 } 103 104 protected void composeString(Complex parent, String parentType, String name, StringType value, int index) { 105 if (value == null) 106 return; 107 Complex t = parent.predicate("fhir:"+parentType+"."+name); 108 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 109 composeElement(t, parentType, name, value, index); 110 } 111 112 protected void composeInteger(Complex parent, String parentType, String name, IntegerType value, int index) { 113 if (value == null) 114 return; 115 Complex t = parent.predicate("fhir:"+parentType+"."+name); 116 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 117 composeElement(t, parentType, name, value, index); 118 } 119 120 protected void composeOid(Complex parent, String parentType, String name, OidType value, int index) { 121 if (value == null) 122 return; 123 Complex t = parent.predicate("fhir:"+parentType+"."+name); 124 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 125 composeElement(t, parentType, name, value, index); 126 } 127 128 protected void composeUri(Complex parent, String parentType, String name, UriType value, int index) { 129 if (value == null) 130 return; 131 Complex t = parent.predicate("fhir:"+parentType+"."+name); 132 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 133 composeElement(t, parentType, name, value, index); 134 } 135 136 protected void composeUuid(Complex parent, String parentType, String name, UuidType value, int index) { 137 if (value == null) 138 return; 139 Complex t = parent.predicate("fhir:"+parentType+"."+name); 140 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 141 composeElement(t, parentType, name, value, index); 142 } 143 144 protected void composeInstant(Complex parent, String parentType, String name, InstantType value, int index) { 145 if (value == null) 146 return; 147 Complex t = parent.predicate("fhir:"+parentType+"."+name); 148 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 149 composeElement(t, parentType, name, value, index); 150 } 151 152 protected void composeBoolean(Complex parent, String parentType, String name, BooleanType value, int index) { 153 if (value == null) 154 return; 155 Complex t = parent.predicate("fhir:"+parentType+"."+name); 156 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 157 composeElement(t, parentType, name, value, index); 158 } 159 160 protected void composeBase64Binary(Complex parent, String parentType, String name, Base64BinaryType value, int index) { 161 if (value == null) 162 return; 163 Complex t = parent.predicate("fhir:"+parentType+"."+name); 164 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 165 composeElement(t, parentType, name, value, index); 166 } 167 168 protected void composeUnsignedInt(Complex parent, String parentType, String name, UnsignedIntType value, int index) { 169 if (value == null) 170 return; 171 Complex t = parent.predicate("fhir:"+parentType+"."+name); 172 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 173 composeElement(t, parentType, name, value, index); 174 } 175 176 protected void composeMarkdown(Complex parent, String parentType, String name, MarkdownType value, int index) { 177 if (value == null) 178 return; 179 Complex t = parent.predicate("fhir:"+parentType+"."+name); 180 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 181 composeElement(t, parentType, name, value, index); 182 } 183 184 protected void composeTime(Complex parent, String parentType, String name, TimeType value, int index) { 185 if (value == null) 186 return; 187 Complex t = parent.predicate("fhir:"+parentType+"."+name); 188 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 189 composeElement(t, parentType, name, value, index); 190 } 191 192 protected void composeId(Complex parent, String parentType, String name, IdType value, int index) { 193 if (value == null) 194 return; 195 Complex t = parent.predicate("fhir:"+parentType+"."+name); 196 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 197 composeElement(t, parentType, name, value, index); 198 } 199 200 protected void composePositiveInt(Complex parent, String parentType, String name, PositiveIntType value, int index) { 201 if (value == null) 202 return; 203 Complex t = parent.predicate("fhir:"+parentType+"."+name); 204 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 205 composeElement(t, parentType, name, value, index); 206 } 207 208 protected void composeDecimal(Complex parent, String parentType, String name, DecimalType value, int index) { 209 if (value == null) 210 return; 211 Complex t = parent.predicate("fhir:"+parentType+"."+name); 212 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 213 composeElement(t, parentType, name, value, index); 214 } 215 216 protected void composeExtension(Complex parent, String parentType, String name, Extension element, int index) { 217 if (element == null) 218 return; 219 Complex t; 220 if (Utilities.noString(parentType)) 221 t = parent; 222 else { 223 t = parent.predicate("fhir:"+parentType+'.'+name); 224 } 225 composeElement(t, "Extension", name, element, index); 226 if (element.hasUrlElement()) 227 composeUri(t, "Extension", "url", element.getUrlElement(), -1); 228 if (element.hasValue()) 229 composeType(t, "Extension", "value", element.getValue(), -1); 230 } 231 232 protected void composeNarrative(Complex parent, String parentType, String name, Narrative element, int index) { 233 if (element == null) 234 return; 235 Complex t; 236 if (Utilities.noString(parentType)) 237 t = parent; 238 else { 239 t = parent.predicate("fhir:"+parentType+'.'+name); 240 } 241 composeElement(t, "Narrative", name, element, index); 242 if (element.hasStatusElement()) 243 composeEnum(t, "Narrative", "status", element.getStatusElement(), -1); 244 if (element.hasDiv()) 245 composeXhtml(t, "Narrative", "div", element.getDiv(), -1); 246 } 247 248 protected void composeReference(Complex parent, String parentType, String name, Reference element, int index) { 249 if (element == null) 250 return; 251 Complex t; 252 if (Utilities.noString(parentType)) 253 t = parent; 254 else { 255 t = parent.predicate("fhir:"+parentType+'.'+name); 256 } 257 composeElement(t, "Reference", name, element, index); 258 if (element.hasReferenceElement()) 259 composeString(t, "Reference", "reference", element.getReferenceElement_(), -1); 260 if (element.hasIdentifier()) 261 composeIdentifier(t, "Reference", "identifier", element.getIdentifier(), -1); 262 if (element.hasDisplayElement()) 263 composeString(t, "Reference", "display", element.getDisplayElement(), -1); 264 } 265 266 protected void composeQuantity(Complex parent, String parentType, String name, Quantity element, int index) { 267 if (element == null) 268 return; 269 Complex t; 270 if (Utilities.noString(parentType)) 271 t = parent; 272 else { 273 t = parent.predicate("fhir:"+parentType+'.'+name); 274 } 275 composeElement(t, "Quantity", name, element, index); 276 if (element.hasValueElement()) 277 composeDecimal(t, "Quantity", "value", element.getValueElement(), -1); 278 if (element.hasComparatorElement()) 279 composeEnum(t, "Quantity", "comparator", element.getComparatorElement(), -1); 280 if (element.hasUnitElement()) 281 composeString(t, "Quantity", "unit", element.getUnitElement(), -1); 282 if (element.hasSystemElement()) 283 composeUri(t, "Quantity", "system", element.getSystemElement(), -1); 284 if (element.hasCodeElement()) 285 composeCode(t, "Quantity", "code", element.getCodeElement(), -1); 286 } 287 288 protected void composePeriod(Complex parent, String parentType, String name, Period element, int index) { 289 if (element == null) 290 return; 291 Complex t; 292 if (Utilities.noString(parentType)) 293 t = parent; 294 else { 295 t = parent.predicate("fhir:"+parentType+'.'+name); 296 } 297 composeElement(t, "Period", name, element, index); 298 if (element.hasStartElement()) 299 composeDateTime(t, "Period", "start", element.getStartElement(), -1); 300 if (element.hasEndElement()) 301 composeDateTime(t, "Period", "end", element.getEndElement(), -1); 302 } 303 304 protected void composeAttachment(Complex parent, String parentType, String name, Attachment element, int index) { 305 if (element == null) 306 return; 307 Complex t; 308 if (Utilities.noString(parentType)) 309 t = parent; 310 else { 311 t = parent.predicate("fhir:"+parentType+'.'+name); 312 } 313 composeElement(t, "Attachment", name, element, index); 314 if (element.hasContentTypeElement()) 315 composeCode(t, "Attachment", "contentType", element.getContentTypeElement(), -1); 316 if (element.hasLanguageElement()) 317 composeCode(t, "Attachment", "language", element.getLanguageElement(), -1); 318 if (element.hasDataElement()) 319 composeBase64Binary(t, "Attachment", "data", element.getDataElement(), -1); 320 if (element.hasUrlElement()) 321 composeUri(t, "Attachment", "url", element.getUrlElement(), -1); 322 if (element.hasSizeElement()) 323 composeUnsignedInt(t, "Attachment", "size", element.getSizeElement(), -1); 324 if (element.hasHashElement()) 325 composeBase64Binary(t, "Attachment", "hash", element.getHashElement(), -1); 326 if (element.hasTitleElement()) 327 composeString(t, "Attachment", "title", element.getTitleElement(), -1); 328 if (element.hasCreationElement()) 329 composeDateTime(t, "Attachment", "creation", element.getCreationElement(), -1); 330 } 331 332 protected void composeDuration(Complex parent, String parentType, String name, Duration element, int index) { 333 if (element == null) 334 return; 335 Complex t; 336 if (Utilities.noString(parentType)) 337 t = parent; 338 else { 339 t = parent.predicate("fhir:"+parentType+'.'+name); 340 } 341 composeElement(t, "Duration", name, element, index); 342 } 343 344 protected void composeCount(Complex parent, String parentType, String name, Count element, int index) { 345 if (element == null) 346 return; 347 Complex t; 348 if (Utilities.noString(parentType)) 349 t = parent; 350 else { 351 t = parent.predicate("fhir:"+parentType+'.'+name); 352 } 353 composeElement(t, "Count", name, element, index); 354 } 355 356 protected void composeRange(Complex parent, String parentType, String name, Range element, int index) { 357 if (element == null) 358 return; 359 Complex t; 360 if (Utilities.noString(parentType)) 361 t = parent; 362 else { 363 t = parent.predicate("fhir:"+parentType+'.'+name); 364 } 365 composeElement(t, "Range", name, element, index); 366 if (element.hasLow()) 367 composeQuantity(t, "Range", "low", element.getLow(), -1); 368 if (element.hasHigh()) 369 composeQuantity(t, "Range", "high", element.getHigh(), -1); 370 } 371 372 protected void composeAnnotation(Complex parent, String parentType, String name, Annotation element, int index) { 373 if (element == null) 374 return; 375 Complex t; 376 if (Utilities.noString(parentType)) 377 t = parent; 378 else { 379 t = parent.predicate("fhir:"+parentType+'.'+name); 380 } 381 composeElement(t, "Annotation", name, element, index); 382 if (element.hasAuthor()) 383 composeType(t, "Annotation", "author", element.getAuthor(), -1); 384 if (element.hasTimeElement()) 385 composeDateTime(t, "Annotation", "time", element.getTimeElement(), -1); 386 if (element.hasTextElement()) 387 composeString(t, "Annotation", "text", element.getTextElement(), -1); 388 } 389 390 protected void composeMoney(Complex parent, String parentType, String name, Money element, int index) { 391 if (element == null) 392 return; 393 Complex t; 394 if (Utilities.noString(parentType)) 395 t = parent; 396 else { 397 t = parent.predicate("fhir:"+parentType+'.'+name); 398 } 399 composeElement(t, "Money", name, element, index); 400 } 401 402 protected void composeIdentifier(Complex parent, String parentType, String name, Identifier element, int index) { 403 if (element == null) 404 return; 405 Complex t; 406 if (Utilities.noString(parentType)) 407 t = parent; 408 else { 409 t = parent.predicate("fhir:"+parentType+'.'+name); 410 } 411 composeElement(t, "Identifier", name, element, index); 412 if (element.hasUseElement()) 413 composeEnum(t, "Identifier", "use", element.getUseElement(), -1); 414 if (element.hasType()) 415 composeCodeableConcept(t, "Identifier", "type", element.getType(), -1); 416 if (element.hasSystemElement()) 417 composeUri(t, "Identifier", "system", element.getSystemElement(), -1); 418 if (element.hasValueElement()) 419 composeString(t, "Identifier", "value", element.getValueElement(), -1); 420 if (element.hasPeriod()) 421 composePeriod(t, "Identifier", "period", element.getPeriod(), -1); 422 if (element.hasAssigner()) 423 composeReference(t, "Identifier", "assigner", element.getAssigner(), -1); 424 } 425 426 protected void composeCoding(Complex parent, String parentType, String name, Coding element, int index) { 427 if (element == null) 428 return; 429 Complex t; 430 if (Utilities.noString(parentType)) 431 t = parent; 432 else { 433 t = parent.predicate("fhir:"+parentType+'.'+name); 434 } 435 composeElement(t, "Coding", name, element, index); 436 decorateCoding(t, element); 437 if (element.hasSystemElement()) 438 composeUri(t, "Coding", "system", element.getSystemElement(), -1); 439 if (element.hasVersionElement()) 440 composeString(t, "Coding", "version", element.getVersionElement(), -1); 441 if (element.hasCodeElement()) 442 composeCode(t, "Coding", "code", element.getCodeElement(), -1); 443 if (element.hasDisplayElement()) 444 composeString(t, "Coding", "display", element.getDisplayElement(), -1); 445 if (element.hasUserSelectedElement()) 446 composeBoolean(t, "Coding", "userSelected", element.getUserSelectedElement(), -1); 447 } 448 449 protected void composeSignature(Complex parent, String parentType, String name, Signature element, int index) { 450 if (element == null) 451 return; 452 Complex t; 453 if (Utilities.noString(parentType)) 454 t = parent; 455 else { 456 t = parent.predicate("fhir:"+parentType+'.'+name); 457 } 458 composeElement(t, "Signature", name, element, index); 459 for (int i = 0; i < element.getType().size(); i++) 460 composeCoding(t, "Signature", "type", element.getType().get(i), i); 461 if (element.hasWhenElement()) 462 composeInstant(t, "Signature", "when", element.getWhenElement(), -1); 463 if (element.hasWho()) 464 composeType(t, "Signature", "who", element.getWho(), -1); 465 if (element.hasOnBehalfOf()) 466 composeType(t, "Signature", "onBehalfOf", element.getOnBehalfOf(), -1); 467 if (element.hasContentTypeElement()) 468 composeCode(t, "Signature", "contentType", element.getContentTypeElement(), -1); 469 if (element.hasBlobElement()) 470 composeBase64Binary(t, "Signature", "blob", element.getBlobElement(), -1); 471 } 472 473 protected void composeSampledData(Complex parent, String parentType, String name, SampledData element, int index) { 474 if (element == null) 475 return; 476 Complex t; 477 if (Utilities.noString(parentType)) 478 t = parent; 479 else { 480 t = parent.predicate("fhir:"+parentType+'.'+name); 481 } 482 composeElement(t, "SampledData", name, element, index); 483 if (element.hasOrigin()) 484 composeQuantity(t, "SampledData", "origin", element.getOrigin(), -1); 485 if (element.hasPeriodElement()) 486 composeDecimal(t, "SampledData", "period", element.getPeriodElement(), -1); 487 if (element.hasFactorElement()) 488 composeDecimal(t, "SampledData", "factor", element.getFactorElement(), -1); 489 if (element.hasLowerLimitElement()) 490 composeDecimal(t, "SampledData", "lowerLimit", element.getLowerLimitElement(), -1); 491 if (element.hasUpperLimitElement()) 492 composeDecimal(t, "SampledData", "upperLimit", element.getUpperLimitElement(), -1); 493 if (element.hasDimensionsElement()) 494 composePositiveInt(t, "SampledData", "dimensions", element.getDimensionsElement(), -1); 495 if (element.hasDataElement()) 496 composeString(t, "SampledData", "data", element.getDataElement(), -1); 497 } 498 499 protected void composeRatio(Complex parent, String parentType, String name, Ratio element, int index) { 500 if (element == null) 501 return; 502 Complex t; 503 if (Utilities.noString(parentType)) 504 t = parent; 505 else { 506 t = parent.predicate("fhir:"+parentType+'.'+name); 507 } 508 composeElement(t, "Ratio", name, element, index); 509 if (element.hasNumerator()) 510 composeQuantity(t, "Ratio", "numerator", element.getNumerator(), -1); 511 if (element.hasDenominator()) 512 composeQuantity(t, "Ratio", "denominator", element.getDenominator(), -1); 513 } 514 515 protected void composeDistance(Complex parent, String parentType, String name, Distance element, int index) { 516 if (element == null) 517 return; 518 Complex t; 519 if (Utilities.noString(parentType)) 520 t = parent; 521 else { 522 t = parent.predicate("fhir:"+parentType+'.'+name); 523 } 524 composeElement(t, "Distance", name, element, index); 525 } 526 527 protected void composeAge(Complex parent, String parentType, String name, Age element, int index) { 528 if (element == null) 529 return; 530 Complex t; 531 if (Utilities.noString(parentType)) 532 t = parent; 533 else { 534 t = parent.predicate("fhir:"+parentType+'.'+name); 535 } 536 composeElement(t, "Age", name, element, index); 537 } 538 539 protected void composeCodeableConcept(Complex parent, String parentType, String name, CodeableConcept element, int index) { 540 if (element == null) 541 return; 542 Complex t; 543 if (Utilities.noString(parentType)) 544 t = parent; 545 else { 546 t = parent.predicate("fhir:"+parentType+'.'+name); 547 } 548 composeElement(t, "CodeableConcept", name, element, index); 549 decorateCodeableConcept(t, element); 550 for (int i = 0; i < element.getCoding().size(); i++) 551 composeCoding(t, "CodeableConcept", "coding", element.getCoding().get(i), i); 552 if (element.hasTextElement()) 553 composeString(t, "CodeableConcept", "text", element.getTextElement(), -1); 554 } 555 556 protected void composeMeta(Complex parent, String parentType, String name, Meta element, int index) { 557 if (element == null) 558 return; 559 Complex t; 560 if (Utilities.noString(parentType)) 561 t = parent; 562 else { 563 t = parent.predicate("fhir:"+parentType+'.'+name); 564 } 565 composeElement(t, "Meta", name, element, index); 566 if (element.hasVersionIdElement()) 567 composeId(t, "Meta", "versionId", element.getVersionIdElement(), -1); 568 if (element.hasLastUpdatedElement()) 569 composeInstant(t, "Meta", "lastUpdated", element.getLastUpdatedElement(), -1); 570 for (int i = 0; i < element.getProfile().size(); i++) 571 composeUri(t, "Meta", "profile", element.getProfile().get(i), i); 572 for (int i = 0; i < element.getSecurity().size(); i++) 573 composeCoding(t, "Meta", "security", element.getSecurity().get(i), i); 574 for (int i = 0; i < element.getTag().size(); i++) 575 composeCoding(t, "Meta", "tag", element.getTag().get(i), i); 576 } 577 578 protected void composeAddress(Complex parent, String parentType, String name, Address element, int index) { 579 if (element == null) 580 return; 581 Complex t; 582 if (Utilities.noString(parentType)) 583 t = parent; 584 else { 585 t = parent.predicate("fhir:"+parentType+'.'+name); 586 } 587 composeElement(t, "Address", name, element, index); 588 if (element.hasUseElement()) 589 composeEnum(t, "Address", "use", element.getUseElement(), -1); 590 if (element.hasTypeElement()) 591 composeEnum(t, "Address", "type", element.getTypeElement(), -1); 592 if (element.hasTextElement()) 593 composeString(t, "Address", "text", element.getTextElement(), -1); 594 for (int i = 0; i < element.getLine().size(); i++) 595 composeString(t, "Address", "line", element.getLine().get(i), i); 596 if (element.hasCityElement()) 597 composeString(t, "Address", "city", element.getCityElement(), -1); 598 if (element.hasDistrictElement()) 599 composeString(t, "Address", "district", element.getDistrictElement(), -1); 600 if (element.hasStateElement()) 601 composeString(t, "Address", "state", element.getStateElement(), -1); 602 if (element.hasPostalCodeElement()) 603 composeString(t, "Address", "postalCode", element.getPostalCodeElement(), -1); 604 if (element.hasCountryElement()) 605 composeString(t, "Address", "country", element.getCountryElement(), -1); 606 if (element.hasPeriod()) 607 composePeriod(t, "Address", "period", element.getPeriod(), -1); 608 } 609 610 protected void composeTriggerDefinition(Complex parent, String parentType, String name, TriggerDefinition element, int index) { 611 if (element == null) 612 return; 613 Complex t; 614 if (Utilities.noString(parentType)) 615 t = parent; 616 else { 617 t = parent.predicate("fhir:"+parentType+'.'+name); 618 } 619 composeElement(t, "TriggerDefinition", name, element, index); 620 if (element.hasTypeElement()) 621 composeEnum(t, "TriggerDefinition", "type", element.getTypeElement(), -1); 622 if (element.hasEventNameElement()) 623 composeString(t, "TriggerDefinition", "eventName", element.getEventNameElement(), -1); 624 if (element.hasEventTiming()) 625 composeType(t, "TriggerDefinition", "eventTiming", element.getEventTiming(), -1); 626 if (element.hasEventData()) 627 composeDataRequirement(t, "TriggerDefinition", "eventData", element.getEventData(), -1); 628 } 629 630 protected void composeContributor(Complex parent, String parentType, String name, Contributor element, int index) { 631 if (element == null) 632 return; 633 Complex t; 634 if (Utilities.noString(parentType)) 635 t = parent; 636 else { 637 t = parent.predicate("fhir:"+parentType+'.'+name); 638 } 639 composeElement(t, "Contributor", name, element, index); 640 if (element.hasTypeElement()) 641 composeEnum(t, "Contributor", "type", element.getTypeElement(), -1); 642 if (element.hasNameElement()) 643 composeString(t, "Contributor", "name", element.getNameElement(), -1); 644 for (int i = 0; i < element.getContact().size(); i++) 645 composeContactDetail(t, "Contributor", "contact", element.getContact().get(i), i); 646 } 647 648 protected void composeDataRequirement(Complex parent, String parentType, String name, DataRequirement element, int index) { 649 if (element == null) 650 return; 651 Complex t; 652 if (Utilities.noString(parentType)) 653 t = parent; 654 else { 655 t = parent.predicate("fhir:"+parentType+'.'+name); 656 } 657 composeElement(t, "DataRequirement", name, element, index); 658 if (element.hasTypeElement()) 659 composeCode(t, "DataRequirement", "type", element.getTypeElement(), -1); 660 for (int i = 0; i < element.getProfile().size(); i++) 661 composeUri(t, "DataRequirement", "profile", element.getProfile().get(i), i); 662 for (int i = 0; i < element.getMustSupport().size(); i++) 663 composeString(t, "DataRequirement", "mustSupport", element.getMustSupport().get(i), i); 664 for (int i = 0; i < element.getCodeFilter().size(); i++) 665 composeDataRequirementDataRequirementCodeFilterComponent(t, "DataRequirement", "codeFilter", element.getCodeFilter().get(i), i); 666 for (int i = 0; i < element.getDateFilter().size(); i++) 667 composeDataRequirementDataRequirementDateFilterComponent(t, "DataRequirement", "dateFilter", element.getDateFilter().get(i), i); 668 } 669 670 protected void composeDataRequirementDataRequirementCodeFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementCodeFilterComponent element, int index) { 671 if (element == null) 672 return; 673 Complex t; 674 if (Utilities.noString(parentType)) 675 t = parent; 676 else { 677 t = parent.predicate("fhir:"+parentType+'.'+name); 678 } 679 composeElement(t, "codeFilter", name, element, index); 680 if (element.hasPathElement()) 681 composeString(t, "DataRequirement", "path", element.getPathElement(), -1); 682 if (element.hasValueSet()) 683 composeType(t, "DataRequirement", "valueSet", element.getValueSet(), -1); 684 for (int i = 0; i < element.getValueCode().size(); i++) 685 composeCode(t, "DataRequirement", "valueCode", element.getValueCode().get(i), i); 686 for (int i = 0; i < element.getValueCoding().size(); i++) 687 composeCoding(t, "DataRequirement", "valueCoding", element.getValueCoding().get(i), i); 688 for (int i = 0; i < element.getValueCodeableConcept().size(); i++) 689 composeCodeableConcept(t, "DataRequirement", "valueCodeableConcept", element.getValueCodeableConcept().get(i), i); 690 } 691 692 protected void composeDataRequirementDataRequirementDateFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementDateFilterComponent element, int index) { 693 if (element == null) 694 return; 695 Complex t; 696 if (Utilities.noString(parentType)) 697 t = parent; 698 else { 699 t = parent.predicate("fhir:"+parentType+'.'+name); 700 } 701 composeElement(t, "dateFilter", name, element, index); 702 if (element.hasPathElement()) 703 composeString(t, "DataRequirement", "path", element.getPathElement(), -1); 704 if (element.hasValue()) 705 composeType(t, "DataRequirement", "value", element.getValue(), -1); 706 } 707 708 protected void composeDosage(Complex parent, String parentType, String name, Dosage element, int index) { 709 if (element == null) 710 return; 711 Complex t; 712 if (Utilities.noString(parentType)) 713 t = parent; 714 else { 715 t = parent.predicate("fhir:"+parentType+'.'+name); 716 } 717 composeElement(t, "Dosage", name, element, index); 718 if (element.hasSequenceElement()) 719 composeInteger(t, "Dosage", "sequence", element.getSequenceElement(), -1); 720 if (element.hasTextElement()) 721 composeString(t, "Dosage", "text", element.getTextElement(), -1); 722 for (int i = 0; i < element.getAdditionalInstruction().size(); i++) 723 composeCodeableConcept(t, "Dosage", "additionalInstruction", element.getAdditionalInstruction().get(i), i); 724 if (element.hasPatientInstructionElement()) 725 composeString(t, "Dosage", "patientInstruction", element.getPatientInstructionElement(), -1); 726 if (element.hasTiming()) 727 composeTiming(t, "Dosage", "timing", element.getTiming(), -1); 728 if (element.hasAsNeeded()) 729 composeType(t, "Dosage", "asNeeded", element.getAsNeeded(), -1); 730 if (element.hasSite()) 731 composeCodeableConcept(t, "Dosage", "site", element.getSite(), -1); 732 if (element.hasRoute()) 733 composeCodeableConcept(t, "Dosage", "route", element.getRoute(), -1); 734 if (element.hasMethod()) 735 composeCodeableConcept(t, "Dosage", "method", element.getMethod(), -1); 736 if (element.hasDose()) 737 composeType(t, "Dosage", "dose", element.getDose(), -1); 738 if (element.hasMaxDosePerPeriod()) 739 composeRatio(t, "Dosage", "maxDosePerPeriod", element.getMaxDosePerPeriod(), -1); 740 if (element.hasMaxDosePerAdministration()) 741 composeQuantity(t, "Dosage", "maxDosePerAdministration", element.getMaxDosePerAdministration(), -1); 742 if (element.hasMaxDosePerLifetime()) 743 composeQuantity(t, "Dosage", "maxDosePerLifetime", element.getMaxDosePerLifetime(), -1); 744 if (element.hasRate()) 745 composeType(t, "Dosage", "rate", element.getRate(), -1); 746 } 747 748 protected void composeRelatedArtifact(Complex parent, String parentType, String name, RelatedArtifact element, int index) { 749 if (element == null) 750 return; 751 Complex t; 752 if (Utilities.noString(parentType)) 753 t = parent; 754 else { 755 t = parent.predicate("fhir:"+parentType+'.'+name); 756 } 757 composeElement(t, "RelatedArtifact", name, element, index); 758 if (element.hasTypeElement()) 759 composeEnum(t, "RelatedArtifact", "type", element.getTypeElement(), -1); 760 if (element.hasDisplayElement()) 761 composeString(t, "RelatedArtifact", "display", element.getDisplayElement(), -1); 762 if (element.hasCitationElement()) 763 composeString(t, "RelatedArtifact", "citation", element.getCitationElement(), -1); 764 if (element.hasUrlElement()) 765 composeUri(t, "RelatedArtifact", "url", element.getUrlElement(), -1); 766 if (element.hasDocument()) 767 composeAttachment(t, "RelatedArtifact", "document", element.getDocument(), -1); 768 if (element.hasResource()) 769 composeReference(t, "RelatedArtifact", "resource", element.getResource(), -1); 770 } 771 772 protected void composeContactDetail(Complex parent, String parentType, String name, ContactDetail element, int index) { 773 if (element == null) 774 return; 775 Complex t; 776 if (Utilities.noString(parentType)) 777 t = parent; 778 else { 779 t = parent.predicate("fhir:"+parentType+'.'+name); 780 } 781 composeElement(t, "ContactDetail", name, element, index); 782 if (element.hasNameElement()) 783 composeString(t, "ContactDetail", "name", element.getNameElement(), -1); 784 for (int i = 0; i < element.getTelecom().size(); i++) 785 composeContactPoint(t, "ContactDetail", "telecom", element.getTelecom().get(i), i); 786 } 787 788 protected void composeHumanName(Complex parent, String parentType, String name, HumanName element, int index) { 789 if (element == null) 790 return; 791 Complex t; 792 if (Utilities.noString(parentType)) 793 t = parent; 794 else { 795 t = parent.predicate("fhir:"+parentType+'.'+name); 796 } 797 composeElement(t, "HumanName", name, element, index); 798 if (element.hasUseElement()) 799 composeEnum(t, "HumanName", "use", element.getUseElement(), -1); 800 if (element.hasTextElement()) 801 composeString(t, "HumanName", "text", element.getTextElement(), -1); 802 if (element.hasFamilyElement()) 803 composeString(t, "HumanName", "family", element.getFamilyElement(), -1); 804 for (int i = 0; i < element.getGiven().size(); i++) 805 composeString(t, "HumanName", "given", element.getGiven().get(i), i); 806 for (int i = 0; i < element.getPrefix().size(); i++) 807 composeString(t, "HumanName", "prefix", element.getPrefix().get(i), i); 808 for (int i = 0; i < element.getSuffix().size(); i++) 809 composeString(t, "HumanName", "suffix", element.getSuffix().get(i), i); 810 if (element.hasPeriod()) 811 composePeriod(t, "HumanName", "period", element.getPeriod(), -1); 812 } 813 814 protected void composeContactPoint(Complex parent, String parentType, String name, ContactPoint element, int index) { 815 if (element == null) 816 return; 817 Complex t; 818 if (Utilities.noString(parentType)) 819 t = parent; 820 else { 821 t = parent.predicate("fhir:"+parentType+'.'+name); 822 } 823 composeElement(t, "ContactPoint", name, element, index); 824 if (element.hasSystemElement()) 825 composeEnum(t, "ContactPoint", "system", element.getSystemElement(), -1); 826 if (element.hasValueElement()) 827 composeString(t, "ContactPoint", "value", element.getValueElement(), -1); 828 if (element.hasUseElement()) 829 composeEnum(t, "ContactPoint", "use", element.getUseElement(), -1); 830 if (element.hasRankElement()) 831 composePositiveInt(t, "ContactPoint", "rank", element.getRankElement(), -1); 832 if (element.hasPeriod()) 833 composePeriod(t, "ContactPoint", "period", element.getPeriod(), -1); 834 } 835 836 protected void composeUsageContext(Complex parent, String parentType, String name, UsageContext element, int index) { 837 if (element == null) 838 return; 839 Complex t; 840 if (Utilities.noString(parentType)) 841 t = parent; 842 else { 843 t = parent.predicate("fhir:"+parentType+'.'+name); 844 } 845 composeElement(t, "UsageContext", name, element, index); 846 if (element.hasCode()) 847 composeCoding(t, "UsageContext", "code", element.getCode(), -1); 848 if (element.hasValue()) 849 composeType(t, "UsageContext", "value", element.getValue(), -1); 850 } 851 852 protected void composeTiming(Complex parent, String parentType, String name, Timing element, int index) { 853 if (element == null) 854 return; 855 Complex t; 856 if (Utilities.noString(parentType)) 857 t = parent; 858 else { 859 t = parent.predicate("fhir:"+parentType+'.'+name); 860 } 861 composeElement(t, "Timing", name, element, index); 862 for (int i = 0; i < element.getEvent().size(); i++) 863 composeDateTime(t, "Timing", "event", element.getEvent().get(i), i); 864 if (element.hasRepeat()) 865 composeTimingTimingRepeatComponent(t, "Timing", "repeat", element.getRepeat(), -1); 866 if (element.hasCode()) 867 composeCodeableConcept(t, "Timing", "code", element.getCode(), -1); 868 } 869 870 protected void composeTimingTimingRepeatComponent(Complex parent, String parentType, String name, Timing.TimingRepeatComponent element, int index) { 871 if (element == null) 872 return; 873 Complex t; 874 if (Utilities.noString(parentType)) 875 t = parent; 876 else { 877 t = parent.predicate("fhir:"+parentType+'.'+name); 878 } 879 composeElement(t, "repeat", name, element, index); 880 if (element.hasBounds()) 881 composeType(t, "Timing", "bounds", element.getBounds(), -1); 882 if (element.hasCountElement()) 883 composeInteger(t, "Timing", "count", element.getCountElement(), -1); 884 if (element.hasCountMaxElement()) 885 composeInteger(t, "Timing", "countMax", element.getCountMaxElement(), -1); 886 if (element.hasDurationElement()) 887 composeDecimal(t, "Timing", "duration", element.getDurationElement(), -1); 888 if (element.hasDurationMaxElement()) 889 composeDecimal(t, "Timing", "durationMax", element.getDurationMaxElement(), -1); 890 if (element.hasDurationUnitElement()) 891 composeEnum(t, "Timing", "durationUnit", element.getDurationUnitElement(), -1); 892 if (element.hasFrequencyElement()) 893 composeInteger(t, "Timing", "frequency", element.getFrequencyElement(), -1); 894 if (element.hasFrequencyMaxElement()) 895 composeInteger(t, "Timing", "frequencyMax", element.getFrequencyMaxElement(), -1); 896 if (element.hasPeriodElement()) 897 composeDecimal(t, "Timing", "period", element.getPeriodElement(), -1); 898 if (element.hasPeriodMaxElement()) 899 composeDecimal(t, "Timing", "periodMax", element.getPeriodMaxElement(), -1); 900 if (element.hasPeriodUnitElement()) 901 composeEnum(t, "Timing", "periodUnit", element.getPeriodUnitElement(), -1); 902 for (int i = 0; i < element.getDayOfWeek().size(); i++) 903 composeEnum(t, "Timing", "dayOfWeek", element.getDayOfWeek().get(i), i); 904 for (int i = 0; i < element.getTimeOfDay().size(); i++) 905 composeTime(t, "Timing", "timeOfDay", element.getTimeOfDay().get(i), i); 906 for (int i = 0; i < element.getWhen().size(); i++) 907 composeEnum(t, "Timing", "when", element.getWhen().get(i), i); 908 if (element.hasOffsetElement()) 909 composeUnsignedInt(t, "Timing", "offset", element.getOffsetElement(), -1); 910 } 911 912 protected void composeElementDefinition(Complex parent, String parentType, String name, ElementDefinition element, int index) { 913 if (element == null) 914 return; 915 Complex t; 916 if (Utilities.noString(parentType)) 917 t = parent; 918 else { 919 t = parent.predicate("fhir:"+parentType+'.'+name); 920 } 921 composeElement(t, "ElementDefinition", name, element, index); 922 if (element.hasPathElement()) 923 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 924 for (int i = 0; i < element.getRepresentation().size(); i++) 925 composeEnum(t, "ElementDefinition", "representation", element.getRepresentation().get(i), i); 926 if (element.hasSliceNameElement()) 927 composeString(t, "ElementDefinition", "sliceName", element.getSliceNameElement(), -1); 928 if (element.hasLabelElement()) 929 composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1); 930 for (int i = 0; i < element.getCode().size(); i++) 931 composeCoding(t, "ElementDefinition", "code", element.getCode().get(i), i); 932 if (element.hasSlicing()) 933 composeElementDefinitionElementDefinitionSlicingComponent(t, "ElementDefinition", "slicing", element.getSlicing(), -1); 934 if (element.hasShortElement()) 935 composeString(t, "ElementDefinition", "short", element.getShortElement(), -1); 936 if (element.hasDefinitionElement()) 937 composeMarkdown(t, "ElementDefinition", "definition", element.getDefinitionElement(), -1); 938 if (element.hasCommentElement()) 939 composeMarkdown(t, "ElementDefinition", "comment", element.getCommentElement(), -1); 940 if (element.hasRequirementsElement()) 941 composeMarkdown(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1); 942 for (int i = 0; i < element.getAlias().size(); i++) 943 composeString(t, "ElementDefinition", "alias", element.getAlias().get(i), i); 944 if (element.hasMinElement()) 945 composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1); 946 if (element.hasMaxElement()) 947 composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1); 948 if (element.hasBase()) 949 composeElementDefinitionElementDefinitionBaseComponent(t, "ElementDefinition", "base", element.getBase(), -1); 950 if (element.hasContentReferenceElement()) 951 composeUri(t, "ElementDefinition", "contentReference", element.getContentReferenceElement(), -1); 952 for (int i = 0; i < element.getType().size(); i++) 953 composeElementDefinitionTypeRefComponent(t, "ElementDefinition", "type", element.getType().get(i), i); 954 if (element.hasDefaultValue()) 955 composeType(t, "ElementDefinition", "defaultValue", element.getDefaultValue(), -1); 956 if (element.hasMeaningWhenMissingElement()) 957 composeMarkdown(t, "ElementDefinition", "meaningWhenMissing", element.getMeaningWhenMissingElement(), -1); 958 if (element.hasOrderMeaningElement()) 959 composeString(t, "ElementDefinition", "orderMeaning", element.getOrderMeaningElement(), -1); 960 if (element.hasFixed()) 961 composeType(t, "ElementDefinition", "fixed", element.getFixed(), -1); 962 if (element.hasPattern()) 963 composeType(t, "ElementDefinition", "pattern", element.getPattern(), -1); 964 for (int i = 0; i < element.getExample().size(); i++) 965 composeElementDefinitionElementDefinitionExampleComponent(t, "ElementDefinition", "example", element.getExample().get(i), i); 966 if (element.hasMinValue()) 967 composeType(t, "ElementDefinition", "minValue", element.getMinValue(), -1); 968 if (element.hasMaxValue()) 969 composeType(t, "ElementDefinition", "maxValue", element.getMaxValue(), -1); 970 if (element.hasMaxLengthElement()) 971 composeInteger(t, "ElementDefinition", "maxLength", element.getMaxLengthElement(), -1); 972 for (int i = 0; i < element.getCondition().size(); i++) 973 composeId(t, "ElementDefinition", "condition", element.getCondition().get(i), i); 974 for (int i = 0; i < element.getConstraint().size(); i++) 975 composeElementDefinitionElementDefinitionConstraintComponent(t, "ElementDefinition", "constraint", element.getConstraint().get(i), i); 976 if (element.hasMustSupportElement()) 977 composeBoolean(t, "ElementDefinition", "mustSupport", element.getMustSupportElement(), -1); 978 if (element.hasIsModifierElement()) 979 composeBoolean(t, "ElementDefinition", "isModifier", element.getIsModifierElement(), -1); 980 if (element.hasIsSummaryElement()) 981 composeBoolean(t, "ElementDefinition", "isSummary", element.getIsSummaryElement(), -1); 982 if (element.hasBinding()) 983 composeElementDefinitionElementDefinitionBindingComponent(t, "ElementDefinition", "binding", element.getBinding(), -1); 984 for (int i = 0; i < element.getMapping().size(); i++) 985 composeElementDefinitionElementDefinitionMappingComponent(t, "ElementDefinition", "mapping", element.getMapping().get(i), i); 986 } 987 988 protected void composeElementDefinitionElementDefinitionSlicingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingComponent element, int index) { 989 if (element == null) 990 return; 991 Complex t; 992 if (Utilities.noString(parentType)) 993 t = parent; 994 else { 995 t = parent.predicate("fhir:"+parentType+'.'+name); 996 } 997 composeElement(t, "slicing", name, element, index); 998 for (int i = 0; i < element.getDiscriminator().size(); i++) 999 composeElementDefinitionElementDefinitionSlicingDiscriminatorComponent(t, "ElementDefinition", "discriminator", element.getDiscriminator().get(i), i); 1000 if (element.hasDescriptionElement()) 1001 composeString(t, "ElementDefinition", "description", element.getDescriptionElement(), -1); 1002 if (element.hasOrderedElement()) 1003 composeBoolean(t, "ElementDefinition", "ordered", element.getOrderedElement(), -1); 1004 if (element.hasRulesElement()) 1005 composeEnum(t, "ElementDefinition", "rules", element.getRulesElement(), -1); 1006 } 1007 1008 protected void composeElementDefinitionElementDefinitionSlicingDiscriminatorComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingDiscriminatorComponent element, int index) { 1009 if (element == null) 1010 return; 1011 Complex t; 1012 if (Utilities.noString(parentType)) 1013 t = parent; 1014 else { 1015 t = parent.predicate("fhir:"+parentType+'.'+name); 1016 } 1017 composeElement(t, "discriminator", name, element, index); 1018 if (element.hasTypeElement()) 1019 composeEnum(t, "ElementDefinition", "type", element.getTypeElement(), -1); 1020 if (element.hasPathElement()) 1021 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 1022 } 1023 1024 protected void composeElementDefinitionElementDefinitionBaseComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBaseComponent element, int index) { 1025 if (element == null) 1026 return; 1027 Complex t; 1028 if (Utilities.noString(parentType)) 1029 t = parent; 1030 else { 1031 t = parent.predicate("fhir:"+parentType+'.'+name); 1032 } 1033 composeElement(t, "base", name, element, index); 1034 if (element.hasPathElement()) 1035 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 1036 if (element.hasMinElement()) 1037 composeUnsignedInt(t, "ElementDefinition", "min", element.getMinElement(), -1); 1038 if (element.hasMaxElement()) 1039 composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1); 1040 } 1041 1042 protected void composeElementDefinitionTypeRefComponent(Complex parent, String parentType, String name, ElementDefinition.TypeRefComponent element, int index) { 1043 if (element == null) 1044 return; 1045 Complex t; 1046 if (Utilities.noString(parentType)) 1047 t = parent; 1048 else { 1049 t = parent.predicate("fhir:"+parentType+'.'+name); 1050 } 1051 composeElement(t, "type", name, element, index); 1052 if (element.hasCodeElement()) 1053 composeUri(t, "ElementDefinition", "code", element.getCodeElement(), -1); 1054 if (element.hasProfileElement()) 1055 composeUri(t, "ElementDefinition", "profile", element.getProfileElement(), -1); 1056 if (element.hasTargetProfileElement()) 1057 composeUri(t, "ElementDefinition", "targetProfile", element.getTargetProfileElement(), -1); 1058 for (int i = 0; i < element.getAggregation().size(); i++) 1059 composeEnum(t, "ElementDefinition", "aggregation", element.getAggregation().get(i), i); 1060 if (element.hasVersioningElement()) 1061 composeEnum(t, "ElementDefinition", "versioning", element.getVersioningElement(), -1); 1062 } 1063 1064 protected void composeElementDefinitionElementDefinitionExampleComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionExampleComponent element, int index) { 1065 if (element == null) 1066 return; 1067 Complex t; 1068 if (Utilities.noString(parentType)) 1069 t = parent; 1070 else { 1071 t = parent.predicate("fhir:"+parentType+'.'+name); 1072 } 1073 composeElement(t, "example", name, element, index); 1074 if (element.hasLabelElement()) 1075 composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1); 1076 if (element.hasValue()) 1077 composeType(t, "ElementDefinition", "value", element.getValue(), -1); 1078 } 1079 1080 protected void composeElementDefinitionElementDefinitionConstraintComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionConstraintComponent element, int index) { 1081 if (element == null) 1082 return; 1083 Complex t; 1084 if (Utilities.noString(parentType)) 1085 t = parent; 1086 else { 1087 t = parent.predicate("fhir:"+parentType+'.'+name); 1088 } 1089 composeElement(t, "constraint", name, element, index); 1090 if (element.hasKeyElement()) 1091 composeId(t, "ElementDefinition", "key", element.getKeyElement(), -1); 1092 if (element.hasRequirementsElement()) 1093 composeString(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1); 1094 if (element.hasSeverityElement()) 1095 composeEnum(t, "ElementDefinition", "severity", element.getSeverityElement(), -1); 1096 if (element.hasHumanElement()) 1097 composeString(t, "ElementDefinition", "human", element.getHumanElement(), -1); 1098 if (element.hasExpressionElement()) 1099 composeString(t, "ElementDefinition", "expression", element.getExpressionElement(), -1); 1100 if (element.hasXpathElement()) 1101 composeString(t, "ElementDefinition", "xpath", element.getXpathElement(), -1); 1102 if (element.hasSourceElement()) 1103 composeUri(t, "ElementDefinition", "source", element.getSourceElement(), -1); 1104 } 1105 1106 protected void composeElementDefinitionElementDefinitionBindingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingComponent element, int index) { 1107 if (element == null) 1108 return; 1109 Complex t; 1110 if (Utilities.noString(parentType)) 1111 t = parent; 1112 else { 1113 t = parent.predicate("fhir:"+parentType+'.'+name); 1114 } 1115 composeElement(t, "binding", name, element, index); 1116 if (element.hasStrengthElement()) 1117 composeEnum(t, "ElementDefinition", "strength", element.getStrengthElement(), -1); 1118 if (element.hasDescriptionElement()) 1119 composeString(t, "ElementDefinition", "description", element.getDescriptionElement(), -1); 1120 if (element.hasValueSet()) 1121 composeType(t, "ElementDefinition", "valueSet", element.getValueSet(), -1); 1122 } 1123 1124 protected void composeElementDefinitionElementDefinitionMappingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionMappingComponent element, int index) { 1125 if (element == null) 1126 return; 1127 Complex t; 1128 if (Utilities.noString(parentType)) 1129 t = parent; 1130 else { 1131 t = parent.predicate("fhir:"+parentType+'.'+name); 1132 } 1133 composeElement(t, "mapping", name, element, index); 1134 if (element.hasIdentityElement()) 1135 composeId(t, "ElementDefinition", "identity", element.getIdentityElement(), -1); 1136 if (element.hasLanguageElement()) 1137 composeCode(t, "ElementDefinition", "language", element.getLanguageElement(), -1); 1138 if (element.hasMapElement()) 1139 composeString(t, "ElementDefinition", "map", element.getMapElement(), -1); 1140 if (element.hasCommentElement()) 1141 composeString(t, "ElementDefinition", "comment", element.getCommentElement(), -1); 1142 } 1143 1144 protected void composeParameterDefinition(Complex parent, String parentType, String name, ParameterDefinition element, int index) { 1145 if (element == null) 1146 return; 1147 Complex t; 1148 if (Utilities.noString(parentType)) 1149 t = parent; 1150 else { 1151 t = parent.predicate("fhir:"+parentType+'.'+name); 1152 } 1153 composeElement(t, "ParameterDefinition", name, element, index); 1154 if (element.hasNameElement()) 1155 composeCode(t, "ParameterDefinition", "name", element.getNameElement(), -1); 1156 if (element.hasUseElement()) 1157 composeEnum(t, "ParameterDefinition", "use", element.getUseElement(), -1); 1158 if (element.hasMinElement()) 1159 composeInteger(t, "ParameterDefinition", "min", element.getMinElement(), -1); 1160 if (element.hasMaxElement()) 1161 composeString(t, "ParameterDefinition", "max", element.getMaxElement(), -1); 1162 if (element.hasDocumentationElement()) 1163 composeString(t, "ParameterDefinition", "documentation", element.getDocumentationElement(), -1); 1164 if (element.hasTypeElement()) 1165 composeCode(t, "ParameterDefinition", "type", element.getTypeElement(), -1); 1166 if (element.hasProfile()) 1167 composeReference(t, "ParameterDefinition", "profile", element.getProfile(), -1); 1168 } 1169 1170 protected void composeDomainResource(Complex t, String parentType, String name, DomainResource element, int index) { 1171 composeResource(t, parentType, name, element, index); 1172 if (element.hasText()) 1173 composeNarrative(t, "DomainResource", "text", element.getText(), -1); 1174 for (int i = 0; i < element.getContained().size(); i++) 1175 composeResource(t, "DomainResource", "contained", element.getContained().get(i), i); 1176 for (int i = 0; i < element.getExtension().size(); i++) 1177 composeExtension(t, "DomainResource", "extension", element.getExtension().get(i), i); 1178 for (int i = 0; i < element.getModifierExtension().size(); i++) 1179 composeExtension(t, "DomainResource", "modifierExtension", element.getModifierExtension().get(i), i); 1180 } 1181 1182 protected void composeParameters(Complex parent, String parentType, String name, Parameters element, int index) { 1183 if (element == null) 1184 return; 1185 Complex t; 1186 if (Utilities.noString(parentType)) 1187 t = parent; 1188 else { 1189 t = parent.predicate("fhir:"+parentType+'.'+name); 1190 } 1191 composeResource(t, "Parameters", name, element, index); 1192 for (int i = 0; i < element.getParameter().size(); i++) 1193 composeParametersParametersParameterComponent(t, "Parameters", "parameter", element.getParameter().get(i), i); 1194 } 1195 1196 protected void composeParametersParametersParameterComponent(Complex parent, String parentType, String name, Parameters.ParametersParameterComponent element, int index) { 1197 if (element == null) 1198 return; 1199 Complex t; 1200 if (Utilities.noString(parentType)) 1201 t = parent; 1202 else { 1203 t = parent.predicate("fhir:"+parentType+'.'+name); 1204 } 1205 composeBackboneElement(t, "parameter", name, element, index); 1206 if (element.hasNameElement()) 1207 composeString(t, "Parameters", "name", element.getNameElement(), -1); 1208 if (element.hasValue()) 1209 composeType(t, "Parameters", "value", element.getValue(), -1); 1210 if (element.hasResource()) 1211 composeResource(t, "Parameters", "resource", element.getResource(), -1); 1212 for (int i = 0; i < element.getPart().size(); i++) 1213 composeParametersParametersParameterComponent(t, "Parameters", "part", element.getPart().get(i), i); 1214 } 1215 1216 protected void composeResource(Complex t, String parentType, String name, Resource element, int index) { 1217 if (element.hasIdElement()) 1218 composeId(t, "Resource", "id", element.getIdElement(), -1); 1219 if (element.hasMeta()) 1220 composeMeta(t, "Resource", "meta", element.getMeta(), -1); 1221 if (element.hasImplicitRulesElement()) 1222 composeUri(t, "Resource", "implicitRules", element.getImplicitRulesElement(), -1); 1223 if (element.hasLanguageElement()) 1224 composeCode(t, "Resource", "language", element.getLanguageElement(), -1); 1225 } 1226 1227 protected void composeAccount(Complex parent, String parentType, String name, Account element, int index) { 1228 if (element == null) 1229 return; 1230 Complex t; 1231 if (Utilities.noString(parentType)) 1232 t = parent; 1233 else { 1234 t = parent.predicate("fhir:"+parentType+'.'+name); 1235 } 1236 composeDomainResource(t, "Account", name, element, index); 1237 for (int i = 0; i < element.getIdentifier().size(); i++) 1238 composeIdentifier(t, "Account", "identifier", element.getIdentifier().get(i), i); 1239 if (element.hasStatusElement()) 1240 composeEnum(t, "Account", "status", element.getStatusElement(), -1); 1241 if (element.hasType()) 1242 composeCodeableConcept(t, "Account", "type", element.getType(), -1); 1243 if (element.hasNameElement()) 1244 composeString(t, "Account", "name", element.getNameElement(), -1); 1245 if (element.hasSubject()) 1246 composeReference(t, "Account", "subject", element.getSubject(), -1); 1247 if (element.hasPeriod()) 1248 composePeriod(t, "Account", "period", element.getPeriod(), -1); 1249 if (element.hasActive()) 1250 composePeriod(t, "Account", "active", element.getActive(), -1); 1251 if (element.hasBalance()) 1252 composeMoney(t, "Account", "balance", element.getBalance(), -1); 1253 for (int i = 0; i < element.getCoverage().size(); i++) 1254 composeAccountCoverageComponent(t, "Account", "coverage", element.getCoverage().get(i), i); 1255 if (element.hasOwner()) 1256 composeReference(t, "Account", "owner", element.getOwner(), -1); 1257 if (element.hasDescriptionElement()) 1258 composeString(t, "Account", "description", element.getDescriptionElement(), -1); 1259 for (int i = 0; i < element.getGuarantor().size(); i++) 1260 composeAccountGuarantorComponent(t, "Account", "guarantor", element.getGuarantor().get(i), i); 1261 } 1262 1263 protected void composeAccountCoverageComponent(Complex parent, String parentType, String name, Account.CoverageComponent element, int index) { 1264 if (element == null) 1265 return; 1266 Complex t; 1267 if (Utilities.noString(parentType)) 1268 t = parent; 1269 else { 1270 t = parent.predicate("fhir:"+parentType+'.'+name); 1271 } 1272 composeBackboneElement(t, "coverage", name, element, index); 1273 if (element.hasCoverage()) 1274 composeReference(t, "Account", "coverage", element.getCoverage(), -1); 1275 if (element.hasPriorityElement()) 1276 composePositiveInt(t, "Account", "priority", element.getPriorityElement(), -1); 1277 } 1278 1279 protected void composeAccountGuarantorComponent(Complex parent, String parentType, String name, Account.GuarantorComponent element, int index) { 1280 if (element == null) 1281 return; 1282 Complex t; 1283 if (Utilities.noString(parentType)) 1284 t = parent; 1285 else { 1286 t = parent.predicate("fhir:"+parentType+'.'+name); 1287 } 1288 composeBackboneElement(t, "guarantor", name, element, index); 1289 if (element.hasParty()) 1290 composeReference(t, "Account", "party", element.getParty(), -1); 1291 if (element.hasOnHoldElement()) 1292 composeBoolean(t, "Account", "onHold", element.getOnHoldElement(), -1); 1293 if (element.hasPeriod()) 1294 composePeriod(t, "Account", "period", element.getPeriod(), -1); 1295 } 1296 1297 protected void composeActivityDefinition(Complex parent, String parentType, String name, ActivityDefinition element, int index) { 1298 if (element == null) 1299 return; 1300 Complex t; 1301 if (Utilities.noString(parentType)) 1302 t = parent; 1303 else { 1304 t = parent.predicate("fhir:"+parentType+'.'+name); 1305 } 1306 composeDomainResource(t, "ActivityDefinition", name, element, index); 1307 if (element.hasUrlElement()) 1308 composeUri(t, "ActivityDefinition", "url", element.getUrlElement(), -1); 1309 for (int i = 0; i < element.getIdentifier().size(); i++) 1310 composeIdentifier(t, "ActivityDefinition", "identifier", element.getIdentifier().get(i), i); 1311 if (element.hasVersionElement()) 1312 composeString(t, "ActivityDefinition", "version", element.getVersionElement(), -1); 1313 if (element.hasNameElement()) 1314 composeString(t, "ActivityDefinition", "name", element.getNameElement(), -1); 1315 if (element.hasTitleElement()) 1316 composeString(t, "ActivityDefinition", "title", element.getTitleElement(), -1); 1317 if (element.hasStatusElement()) 1318 composeEnum(t, "ActivityDefinition", "status", element.getStatusElement(), -1); 1319 if (element.hasExperimentalElement()) 1320 composeBoolean(t, "ActivityDefinition", "experimental", element.getExperimentalElement(), -1); 1321 if (element.hasDateElement()) 1322 composeDateTime(t, "ActivityDefinition", "date", element.getDateElement(), -1); 1323 if (element.hasPublisherElement()) 1324 composeString(t, "ActivityDefinition", "publisher", element.getPublisherElement(), -1); 1325 if (element.hasDescriptionElement()) 1326 composeMarkdown(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1); 1327 if (element.hasPurposeElement()) 1328 composeMarkdown(t, "ActivityDefinition", "purpose", element.getPurposeElement(), -1); 1329 if (element.hasUsageElement()) 1330 composeString(t, "ActivityDefinition", "usage", element.getUsageElement(), -1); 1331 if (element.hasApprovalDateElement()) 1332 composeDate(t, "ActivityDefinition", "approvalDate", element.getApprovalDateElement(), -1); 1333 if (element.hasLastReviewDateElement()) 1334 composeDate(t, "ActivityDefinition", "lastReviewDate", element.getLastReviewDateElement(), -1); 1335 if (element.hasEffectivePeriod()) 1336 composePeriod(t, "ActivityDefinition", "effectivePeriod", element.getEffectivePeriod(), -1); 1337 for (int i = 0; i < element.getUseContext().size(); i++) 1338 composeUsageContext(t, "ActivityDefinition", "useContext", element.getUseContext().get(i), i); 1339 for (int i = 0; i < element.getJurisdiction().size(); i++) 1340 composeCodeableConcept(t, "ActivityDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 1341 for (int i = 0; i < element.getTopic().size(); i++) 1342 composeCodeableConcept(t, "ActivityDefinition", "topic", element.getTopic().get(i), i); 1343 for (int i = 0; i < element.getContributor().size(); i++) 1344 composeContributor(t, "ActivityDefinition", "contributor", element.getContributor().get(i), i); 1345 for (int i = 0; i < element.getContact().size(); i++) 1346 composeContactDetail(t, "ActivityDefinition", "contact", element.getContact().get(i), i); 1347 if (element.hasCopyrightElement()) 1348 composeMarkdown(t, "ActivityDefinition", "copyright", element.getCopyrightElement(), -1); 1349 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 1350 composeRelatedArtifact(t, "ActivityDefinition", "relatedArtifact", element.getRelatedArtifact().get(i), i); 1351 for (int i = 0; i < element.getLibrary().size(); i++) 1352 composeReference(t, "ActivityDefinition", "library", element.getLibrary().get(i), i); 1353 if (element.hasKindElement()) 1354 composeEnum(t, "ActivityDefinition", "kind", element.getKindElement(), -1); 1355 if (element.hasCode()) 1356 composeCodeableConcept(t, "ActivityDefinition", "code", element.getCode(), -1); 1357 if (element.hasTiming()) 1358 composeType(t, "ActivityDefinition", "timing", element.getTiming(), -1); 1359 if (element.hasLocation()) 1360 composeReference(t, "ActivityDefinition", "location", element.getLocation(), -1); 1361 for (int i = 0; i < element.getParticipant().size(); i++) 1362 composeActivityDefinitionActivityDefinitionParticipantComponent(t, "ActivityDefinition", "participant", element.getParticipant().get(i), i); 1363 if (element.hasProduct()) 1364 composeType(t, "ActivityDefinition", "product", element.getProduct(), -1); 1365 if (element.hasQuantity()) 1366 composeQuantity(t, "ActivityDefinition", "quantity", element.getQuantity(), -1); 1367 for (int i = 0; i < element.getDosage().size(); i++) 1368 composeDosage(t, "ActivityDefinition", "dosage", element.getDosage().get(i), i); 1369 for (int i = 0; i < element.getBodySite().size(); i++) 1370 composeCodeableConcept(t, "ActivityDefinition", "bodySite", element.getBodySite().get(i), i); 1371 if (element.hasTransform()) 1372 composeReference(t, "ActivityDefinition", "transform", element.getTransform(), -1); 1373 for (int i = 0; i < element.getDynamicValue().size(); i++) 1374 composeActivityDefinitionActivityDefinitionDynamicValueComponent(t, "ActivityDefinition", "dynamicValue", element.getDynamicValue().get(i), i); 1375 } 1376 1377 protected void composeActivityDefinitionActivityDefinitionParticipantComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionParticipantComponent element, int index) { 1378 if (element == null) 1379 return; 1380 Complex t; 1381 if (Utilities.noString(parentType)) 1382 t = parent; 1383 else { 1384 t = parent.predicate("fhir:"+parentType+'.'+name); 1385 } 1386 composeBackboneElement(t, "participant", name, element, index); 1387 if (element.hasTypeElement()) 1388 composeEnum(t, "ActivityDefinition", "type", element.getTypeElement(), -1); 1389 if (element.hasRole()) 1390 composeCodeableConcept(t, "ActivityDefinition", "role", element.getRole(), -1); 1391 } 1392 1393 protected void composeActivityDefinitionActivityDefinitionDynamicValueComponent(Complex parent, String parentType, String name, ActivityDefinition.ActivityDefinitionDynamicValueComponent element, int index) { 1394 if (element == null) 1395 return; 1396 Complex t; 1397 if (Utilities.noString(parentType)) 1398 t = parent; 1399 else { 1400 t = parent.predicate("fhir:"+parentType+'.'+name); 1401 } 1402 composeBackboneElement(t, "dynamicValue", name, element, index); 1403 if (element.hasDescriptionElement()) 1404 composeString(t, "ActivityDefinition", "description", element.getDescriptionElement(), -1); 1405 if (element.hasPathElement()) 1406 composeString(t, "ActivityDefinition", "path", element.getPathElement(), -1); 1407 if (element.hasLanguageElement()) 1408 composeString(t, "ActivityDefinition", "language", element.getLanguageElement(), -1); 1409 if (element.hasExpressionElement()) 1410 composeString(t, "ActivityDefinition", "expression", element.getExpressionElement(), -1); 1411 } 1412 1413 protected void composeAdverseEvent(Complex parent, String parentType, String name, AdverseEvent element, int index) { 1414 if (element == null) 1415 return; 1416 Complex t; 1417 if (Utilities.noString(parentType)) 1418 t = parent; 1419 else { 1420 t = parent.predicate("fhir:"+parentType+'.'+name); 1421 } 1422 composeDomainResource(t, "AdverseEvent", name, element, index); 1423 if (element.hasIdentifier()) 1424 composeIdentifier(t, "AdverseEvent", "identifier", element.getIdentifier(), -1); 1425 if (element.hasCategoryElement()) 1426 composeEnum(t, "AdverseEvent", "category", element.getCategoryElement(), -1); 1427 if (element.hasType()) 1428 composeCodeableConcept(t, "AdverseEvent", "type", element.getType(), -1); 1429 if (element.hasSubject()) 1430 composeReference(t, "AdverseEvent", "subject", element.getSubject(), -1); 1431 if (element.hasDateElement()) 1432 composeDateTime(t, "AdverseEvent", "date", element.getDateElement(), -1); 1433 for (int i = 0; i < element.getReaction().size(); i++) 1434 composeReference(t, "AdverseEvent", "reaction", element.getReaction().get(i), i); 1435 if (element.hasLocation()) 1436 composeReference(t, "AdverseEvent", "location", element.getLocation(), -1); 1437 if (element.hasSeriousness()) 1438 composeCodeableConcept(t, "AdverseEvent", "seriousness", element.getSeriousness(), -1); 1439 if (element.hasOutcome()) 1440 composeCodeableConcept(t, "AdverseEvent", "outcome", element.getOutcome(), -1); 1441 if (element.hasRecorder()) 1442 composeReference(t, "AdverseEvent", "recorder", element.getRecorder(), -1); 1443 if (element.hasEventParticipant()) 1444 composeReference(t, "AdverseEvent", "eventParticipant", element.getEventParticipant(), -1); 1445 if (element.hasDescriptionElement()) 1446 composeString(t, "AdverseEvent", "description", element.getDescriptionElement(), -1); 1447 for (int i = 0; i < element.getSuspectEntity().size(); i++) 1448 composeAdverseEventAdverseEventSuspectEntityComponent(t, "AdverseEvent", "suspectEntity", element.getSuspectEntity().get(i), i); 1449 for (int i = 0; i < element.getSubjectMedicalHistory().size(); i++) 1450 composeReference(t, "AdverseEvent", "subjectMedicalHistory", element.getSubjectMedicalHistory().get(i), i); 1451 for (int i = 0; i < element.getReferenceDocument().size(); i++) 1452 composeReference(t, "AdverseEvent", "referenceDocument", element.getReferenceDocument().get(i), i); 1453 for (int i = 0; i < element.getStudy().size(); i++) 1454 composeReference(t, "AdverseEvent", "study", element.getStudy().get(i), i); 1455 } 1456 1457 protected void composeAdverseEventAdverseEventSuspectEntityComponent(Complex parent, String parentType, String name, AdverseEvent.AdverseEventSuspectEntityComponent element, int index) { 1458 if (element == null) 1459 return; 1460 Complex t; 1461 if (Utilities.noString(parentType)) 1462 t = parent; 1463 else { 1464 t = parent.predicate("fhir:"+parentType+'.'+name); 1465 } 1466 composeBackboneElement(t, "suspectEntity", name, element, index); 1467 if (element.hasInstance()) 1468 composeReference(t, "AdverseEvent", "instance", element.getInstance(), -1); 1469 if (element.hasCausalityElement()) 1470 composeEnum(t, "AdverseEvent", "causality", element.getCausalityElement(), -1); 1471 if (element.hasCausalityAssessment()) 1472 composeCodeableConcept(t, "AdverseEvent", "causalityAssessment", element.getCausalityAssessment(), -1); 1473 if (element.hasCausalityProductRelatednessElement()) 1474 composeString(t, "AdverseEvent", "causalityProductRelatedness", element.getCausalityProductRelatednessElement(), -1); 1475 if (element.hasCausalityMethod()) 1476 composeCodeableConcept(t, "AdverseEvent", "causalityMethod", element.getCausalityMethod(), -1); 1477 if (element.hasCausalityAuthor()) 1478 composeReference(t, "AdverseEvent", "causalityAuthor", element.getCausalityAuthor(), -1); 1479 if (element.hasCausalityResult()) 1480 composeCodeableConcept(t, "AdverseEvent", "causalityResult", element.getCausalityResult(), -1); 1481 } 1482 1483 protected void composeAllergyIntolerance(Complex parent, String parentType, String name, AllergyIntolerance element, int index) { 1484 if (element == null) 1485 return; 1486 Complex t; 1487 if (Utilities.noString(parentType)) 1488 t = parent; 1489 else { 1490 t = parent.predicate("fhir:"+parentType+'.'+name); 1491 } 1492 composeDomainResource(t, "AllergyIntolerance", name, element, index); 1493 for (int i = 0; i < element.getIdentifier().size(); i++) 1494 composeIdentifier(t, "AllergyIntolerance", "identifier", element.getIdentifier().get(i), i); 1495 if (element.hasClinicalStatusElement()) 1496 composeEnum(t, "AllergyIntolerance", "clinicalStatus", element.getClinicalStatusElement(), -1); 1497 if (element.hasVerificationStatusElement()) 1498 composeEnum(t, "AllergyIntolerance", "verificationStatus", element.getVerificationStatusElement(), -1); 1499 if (element.hasTypeElement()) 1500 composeEnum(t, "AllergyIntolerance", "type", element.getTypeElement(), -1); 1501 for (int i = 0; i < element.getCategory().size(); i++) 1502 composeEnum(t, "AllergyIntolerance", "category", element.getCategory().get(i), i); 1503 if (element.hasCriticalityElement()) 1504 composeEnum(t, "AllergyIntolerance", "criticality", element.getCriticalityElement(), -1); 1505 if (element.hasCode()) 1506 composeCodeableConcept(t, "AllergyIntolerance", "code", element.getCode(), -1); 1507 if (element.hasPatient()) 1508 composeReference(t, "AllergyIntolerance", "patient", element.getPatient(), -1); 1509 if (element.hasOnset()) 1510 composeType(t, "AllergyIntolerance", "onset", element.getOnset(), -1); 1511 if (element.hasAssertedDateElement()) 1512 composeDateTime(t, "AllergyIntolerance", "assertedDate", element.getAssertedDateElement(), -1); 1513 if (element.hasRecorder()) 1514 composeReference(t, "AllergyIntolerance", "recorder", element.getRecorder(), -1); 1515 if (element.hasAsserter()) 1516 composeReference(t, "AllergyIntolerance", "asserter", element.getAsserter(), -1); 1517 if (element.hasLastOccurrenceElement()) 1518 composeDateTime(t, "AllergyIntolerance", "lastOccurrence", element.getLastOccurrenceElement(), -1); 1519 for (int i = 0; i < element.getNote().size(); i++) 1520 composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i); 1521 for (int i = 0; i < element.getReaction().size(); i++) 1522 composeAllergyIntoleranceAllergyIntoleranceReactionComponent(t, "AllergyIntolerance", "reaction", element.getReaction().get(i), i); 1523 } 1524 1525 protected void composeAllergyIntoleranceAllergyIntoleranceReactionComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceReactionComponent element, int index) { 1526 if (element == null) 1527 return; 1528 Complex t; 1529 if (Utilities.noString(parentType)) 1530 t = parent; 1531 else { 1532 t = parent.predicate("fhir:"+parentType+'.'+name); 1533 } 1534 composeBackboneElement(t, "reaction", name, element, index); 1535 if (element.hasSubstance()) 1536 composeCodeableConcept(t, "AllergyIntolerance", "substance", element.getSubstance(), -1); 1537 for (int i = 0; i < element.getManifestation().size(); i++) 1538 composeCodeableConcept(t, "AllergyIntolerance", "manifestation", element.getManifestation().get(i), i); 1539 if (element.hasDescriptionElement()) 1540 composeString(t, "AllergyIntolerance", "description", element.getDescriptionElement(), -1); 1541 if (element.hasOnsetElement()) 1542 composeDateTime(t, "AllergyIntolerance", "onset", element.getOnsetElement(), -1); 1543 if (element.hasSeverityElement()) 1544 composeEnum(t, "AllergyIntolerance", "severity", element.getSeverityElement(), -1); 1545 if (element.hasExposureRoute()) 1546 composeCodeableConcept(t, "AllergyIntolerance", "exposureRoute", element.getExposureRoute(), -1); 1547 for (int i = 0; i < element.getNote().size(); i++) 1548 composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i); 1549 } 1550 1551 protected void composeAppointment(Complex parent, String parentType, String name, Appointment element, int index) { 1552 if (element == null) 1553 return; 1554 Complex t; 1555 if (Utilities.noString(parentType)) 1556 t = parent; 1557 else { 1558 t = parent.predicate("fhir:"+parentType+'.'+name); 1559 } 1560 composeDomainResource(t, "Appointment", name, element, index); 1561 for (int i = 0; i < element.getIdentifier().size(); i++) 1562 composeIdentifier(t, "Appointment", "identifier", element.getIdentifier().get(i), i); 1563 if (element.hasStatusElement()) 1564 composeEnum(t, "Appointment", "status", element.getStatusElement(), -1); 1565 if (element.hasServiceCategory()) 1566 composeCodeableConcept(t, "Appointment", "serviceCategory", element.getServiceCategory(), -1); 1567 for (int i = 0; i < element.getServiceType().size(); i++) 1568 composeCodeableConcept(t, "Appointment", "serviceType", element.getServiceType().get(i), i); 1569 for (int i = 0; i < element.getSpecialty().size(); i++) 1570 composeCodeableConcept(t, "Appointment", "specialty", element.getSpecialty().get(i), i); 1571 if (element.hasAppointmentType()) 1572 composeCodeableConcept(t, "Appointment", "appointmentType", element.getAppointmentType(), -1); 1573 for (int i = 0; i < element.getReason().size(); i++) 1574 composeCodeableConcept(t, "Appointment", "reason", element.getReason().get(i), i); 1575 for (int i = 0; i < element.getIndication().size(); i++) 1576 composeReference(t, "Appointment", "indication", element.getIndication().get(i), i); 1577 if (element.hasPriorityElement()) 1578 composeUnsignedInt(t, "Appointment", "priority", element.getPriorityElement(), -1); 1579 if (element.hasDescriptionElement()) 1580 composeString(t, "Appointment", "description", element.getDescriptionElement(), -1); 1581 for (int i = 0; i < element.getSupportingInformation().size(); i++) 1582 composeReference(t, "Appointment", "supportingInformation", element.getSupportingInformation().get(i), i); 1583 if (element.hasStartElement()) 1584 composeInstant(t, "Appointment", "start", element.getStartElement(), -1); 1585 if (element.hasEndElement()) 1586 composeInstant(t, "Appointment", "end", element.getEndElement(), -1); 1587 if (element.hasMinutesDurationElement()) 1588 composePositiveInt(t, "Appointment", "minutesDuration", element.getMinutesDurationElement(), -1); 1589 for (int i = 0; i < element.getSlot().size(); i++) 1590 composeReference(t, "Appointment", "slot", element.getSlot().get(i), i); 1591 if (element.hasCreatedElement()) 1592 composeDateTime(t, "Appointment", "created", element.getCreatedElement(), -1); 1593 if (element.hasCommentElement()) 1594 composeString(t, "Appointment", "comment", element.getCommentElement(), -1); 1595 for (int i = 0; i < element.getIncomingReferral().size(); i++) 1596 composeReference(t, "Appointment", "incomingReferral", element.getIncomingReferral().get(i), i); 1597 for (int i = 0; i < element.getParticipant().size(); i++) 1598 composeAppointmentAppointmentParticipantComponent(t, "Appointment", "participant", element.getParticipant().get(i), i); 1599 for (int i = 0; i < element.getRequestedPeriod().size(); i++) 1600 composePeriod(t, "Appointment", "requestedPeriod", element.getRequestedPeriod().get(i), i); 1601 } 1602 1603 protected void composeAppointmentAppointmentParticipantComponent(Complex parent, String parentType, String name, Appointment.AppointmentParticipantComponent element, int index) { 1604 if (element == null) 1605 return; 1606 Complex t; 1607 if (Utilities.noString(parentType)) 1608 t = parent; 1609 else { 1610 t = parent.predicate("fhir:"+parentType+'.'+name); 1611 } 1612 composeBackboneElement(t, "participant", name, element, index); 1613 for (int i = 0; i < element.getType().size(); i++) 1614 composeCodeableConcept(t, "Appointment", "type", element.getType().get(i), i); 1615 if (element.hasActor()) 1616 composeReference(t, "Appointment", "actor", element.getActor(), -1); 1617 if (element.hasRequiredElement()) 1618 composeEnum(t, "Appointment", "required", element.getRequiredElement(), -1); 1619 if (element.hasStatusElement()) 1620 composeEnum(t, "Appointment", "status", element.getStatusElement(), -1); 1621 } 1622 1623 protected void composeAppointmentResponse(Complex parent, String parentType, String name, AppointmentResponse element, int index) { 1624 if (element == null) 1625 return; 1626 Complex t; 1627 if (Utilities.noString(parentType)) 1628 t = parent; 1629 else { 1630 t = parent.predicate("fhir:"+parentType+'.'+name); 1631 } 1632 composeDomainResource(t, "AppointmentResponse", name, element, index); 1633 for (int i = 0; i < element.getIdentifier().size(); i++) 1634 composeIdentifier(t, "AppointmentResponse", "identifier", element.getIdentifier().get(i), i); 1635 if (element.hasAppointment()) 1636 composeReference(t, "AppointmentResponse", "appointment", element.getAppointment(), -1); 1637 if (element.hasStartElement()) 1638 composeInstant(t, "AppointmentResponse", "start", element.getStartElement(), -1); 1639 if (element.hasEndElement()) 1640 composeInstant(t, "AppointmentResponse", "end", element.getEndElement(), -1); 1641 for (int i = 0; i < element.getParticipantType().size(); i++) 1642 composeCodeableConcept(t, "AppointmentResponse", "participantType", element.getParticipantType().get(i), i); 1643 if (element.hasActor()) 1644 composeReference(t, "AppointmentResponse", "actor", element.getActor(), -1); 1645 if (element.hasParticipantStatusElement()) 1646 composeEnum(t, "AppointmentResponse", "participantStatus", element.getParticipantStatusElement(), -1); 1647 if (element.hasCommentElement()) 1648 composeString(t, "AppointmentResponse", "comment", element.getCommentElement(), -1); 1649 } 1650 1651 protected void composeAuditEvent(Complex parent, String parentType, String name, AuditEvent element, int index) { 1652 if (element == null) 1653 return; 1654 Complex t; 1655 if (Utilities.noString(parentType)) 1656 t = parent; 1657 else { 1658 t = parent.predicate("fhir:"+parentType+'.'+name); 1659 } 1660 composeDomainResource(t, "AuditEvent", name, element, index); 1661 if (element.hasType()) 1662 composeCoding(t, "AuditEvent", "type", element.getType(), -1); 1663 for (int i = 0; i < element.getSubtype().size(); i++) 1664 composeCoding(t, "AuditEvent", "subtype", element.getSubtype().get(i), i); 1665 if (element.hasActionElement()) 1666 composeEnum(t, "AuditEvent", "action", element.getActionElement(), -1); 1667 if (element.hasRecordedElement()) 1668 composeInstant(t, "AuditEvent", "recorded", element.getRecordedElement(), -1); 1669 if (element.hasOutcomeElement()) 1670 composeEnum(t, "AuditEvent", "outcome", element.getOutcomeElement(), -1); 1671 if (element.hasOutcomeDescElement()) 1672 composeString(t, "AuditEvent", "outcomeDesc", element.getOutcomeDescElement(), -1); 1673 for (int i = 0; i < element.getPurposeOfEvent().size(); i++) 1674 composeCodeableConcept(t, "AuditEvent", "purposeOfEvent", element.getPurposeOfEvent().get(i), i); 1675 for (int i = 0; i < element.getAgent().size(); i++) 1676 composeAuditEventAuditEventAgentComponent(t, "AuditEvent", "agent", element.getAgent().get(i), i); 1677 if (element.hasSource()) 1678 composeAuditEventAuditEventSourceComponent(t, "AuditEvent", "source", element.getSource(), -1); 1679 for (int i = 0; i < element.getEntity().size(); i++) 1680 composeAuditEventAuditEventEntityComponent(t, "AuditEvent", "entity", element.getEntity().get(i), i); 1681 } 1682 1683 protected void composeAuditEventAuditEventAgentComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentComponent element, int index) { 1684 if (element == null) 1685 return; 1686 Complex t; 1687 if (Utilities.noString(parentType)) 1688 t = parent; 1689 else { 1690 t = parent.predicate("fhir:"+parentType+'.'+name); 1691 } 1692 composeBackboneElement(t, "agent", name, element, index); 1693 for (int i = 0; i < element.getRole().size(); i++) 1694 composeCodeableConcept(t, "AuditEvent", "role", element.getRole().get(i), i); 1695 if (element.hasReference()) 1696 composeReference(t, "AuditEvent", "reference", element.getReference(), -1); 1697 if (element.hasUserId()) 1698 composeIdentifier(t, "AuditEvent", "userId", element.getUserId(), -1); 1699 if (element.hasAltIdElement()) 1700 composeString(t, "AuditEvent", "altId", element.getAltIdElement(), -1); 1701 if (element.hasNameElement()) 1702 composeString(t, "AuditEvent", "name", element.getNameElement(), -1); 1703 if (element.hasRequestorElement()) 1704 composeBoolean(t, "AuditEvent", "requestor", element.getRequestorElement(), -1); 1705 if (element.hasLocation()) 1706 composeReference(t, "AuditEvent", "location", element.getLocation(), -1); 1707 for (int i = 0; i < element.getPolicy().size(); i++) 1708 composeUri(t, "AuditEvent", "policy", element.getPolicy().get(i), i); 1709 if (element.hasMedia()) 1710 composeCoding(t, "AuditEvent", "media", element.getMedia(), -1); 1711 if (element.hasNetwork()) 1712 composeAuditEventAuditEventAgentNetworkComponent(t, "AuditEvent", "network", element.getNetwork(), -1); 1713 for (int i = 0; i < element.getPurposeOfUse().size(); i++) 1714 composeCodeableConcept(t, "AuditEvent", "purposeOfUse", element.getPurposeOfUse().get(i), i); 1715 } 1716 1717 protected void composeAuditEventAuditEventAgentNetworkComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentNetworkComponent element, int index) { 1718 if (element == null) 1719 return; 1720 Complex t; 1721 if (Utilities.noString(parentType)) 1722 t = parent; 1723 else { 1724 t = parent.predicate("fhir:"+parentType+'.'+name); 1725 } 1726 composeBackboneElement(t, "network", name, element, index); 1727 if (element.hasAddressElement()) 1728 composeString(t, "AuditEvent", "address", element.getAddressElement(), -1); 1729 if (element.hasTypeElement()) 1730 composeEnum(t, "AuditEvent", "type", element.getTypeElement(), -1); 1731 } 1732 1733 protected void composeAuditEventAuditEventSourceComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventSourceComponent element, int index) { 1734 if (element == null) 1735 return; 1736 Complex t; 1737 if (Utilities.noString(parentType)) 1738 t = parent; 1739 else { 1740 t = parent.predicate("fhir:"+parentType+'.'+name); 1741 } 1742 composeBackboneElement(t, "source", name, element, index); 1743 if (element.hasSiteElement()) 1744 composeString(t, "AuditEvent", "site", element.getSiteElement(), -1); 1745 if (element.hasIdentifier()) 1746 composeIdentifier(t, "AuditEvent", "identifier", element.getIdentifier(), -1); 1747 for (int i = 0; i < element.getType().size(); i++) 1748 composeCoding(t, "AuditEvent", "type", element.getType().get(i), i); 1749 } 1750 1751 protected void composeAuditEventAuditEventEntityComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityComponent element, int index) { 1752 if (element == null) 1753 return; 1754 Complex t; 1755 if (Utilities.noString(parentType)) 1756 t = parent; 1757 else { 1758 t = parent.predicate("fhir:"+parentType+'.'+name); 1759 } 1760 composeBackboneElement(t, "entity", name, element, index); 1761 if (element.hasIdentifier()) 1762 composeIdentifier(t, "AuditEvent", "identifier", element.getIdentifier(), -1); 1763 if (element.hasReference()) 1764 composeReference(t, "AuditEvent", "reference", element.getReference(), -1); 1765 if (element.hasType()) 1766 composeCoding(t, "AuditEvent", "type", element.getType(), -1); 1767 if (element.hasRole()) 1768 composeCoding(t, "AuditEvent", "role", element.getRole(), -1); 1769 if (element.hasLifecycle()) 1770 composeCoding(t, "AuditEvent", "lifecycle", element.getLifecycle(), -1); 1771 for (int i = 0; i < element.getSecurityLabel().size(); i++) 1772 composeCoding(t, "AuditEvent", "securityLabel", element.getSecurityLabel().get(i), i); 1773 if (element.hasNameElement()) 1774 composeString(t, "AuditEvent", "name", element.getNameElement(), -1); 1775 if (element.hasDescriptionElement()) 1776 composeString(t, "AuditEvent", "description", element.getDescriptionElement(), -1); 1777 if (element.hasQueryElement()) 1778 composeBase64Binary(t, "AuditEvent", "query", element.getQueryElement(), -1); 1779 for (int i = 0; i < element.getDetail().size(); i++) 1780 composeAuditEventAuditEventEntityDetailComponent(t, "AuditEvent", "detail", element.getDetail().get(i), i); 1781 } 1782 1783 protected void composeAuditEventAuditEventEntityDetailComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityDetailComponent element, int index) { 1784 if (element == null) 1785 return; 1786 Complex t; 1787 if (Utilities.noString(parentType)) 1788 t = parent; 1789 else { 1790 t = parent.predicate("fhir:"+parentType+'.'+name); 1791 } 1792 composeBackboneElement(t, "detail", name, element, index); 1793 if (element.hasTypeElement()) 1794 composeString(t, "AuditEvent", "type", element.getTypeElement(), -1); 1795 if (element.hasValueElement()) 1796 composeBase64Binary(t, "AuditEvent", "value", element.getValueElement(), -1); 1797 } 1798 1799 protected void composeBasic(Complex parent, String parentType, String name, Basic element, int index) { 1800 if (element == null) 1801 return; 1802 Complex t; 1803 if (Utilities.noString(parentType)) 1804 t = parent; 1805 else { 1806 t = parent.predicate("fhir:"+parentType+'.'+name); 1807 } 1808 composeDomainResource(t, "Basic", name, element, index); 1809 for (int i = 0; i < element.getIdentifier().size(); i++) 1810 composeIdentifier(t, "Basic", "identifier", element.getIdentifier().get(i), i); 1811 if (element.hasCode()) 1812 composeCodeableConcept(t, "Basic", "code", element.getCode(), -1); 1813 if (element.hasSubject()) 1814 composeReference(t, "Basic", "subject", element.getSubject(), -1); 1815 if (element.hasCreatedElement()) 1816 composeDate(t, "Basic", "created", element.getCreatedElement(), -1); 1817 if (element.hasAuthor()) 1818 composeReference(t, "Basic", "author", element.getAuthor(), -1); 1819 } 1820 1821 protected void composeBinary(Complex parent, String parentType, String name, Binary element, int index) { 1822 if (element == null) 1823 return; 1824 Complex t; 1825 if (Utilities.noString(parentType)) 1826 t = parent; 1827 else { 1828 t = parent.predicate("fhir:"+parentType+'.'+name); 1829 } 1830 composeResource(t, "Binary", name, element, index); 1831 if (element.hasContentTypeElement()) 1832 composeCode(t, "Binary", "contentType", element.getContentTypeElement(), -1); 1833 if (element.hasSecurityContext()) 1834 composeReference(t, "Binary", "securityContext", element.getSecurityContext(), -1); 1835 if (element.hasContentElement()) 1836 composeBase64Binary(t, "Binary", "content", element.getContentElement(), -1); 1837 } 1838 1839 protected void composeBodySite(Complex parent, String parentType, String name, BodySite element, int index) { 1840 if (element == null) 1841 return; 1842 Complex t; 1843 if (Utilities.noString(parentType)) 1844 t = parent; 1845 else { 1846 t = parent.predicate("fhir:"+parentType+'.'+name); 1847 } 1848 composeDomainResource(t, "BodySite", name, element, index); 1849 for (int i = 0; i < element.getIdentifier().size(); i++) 1850 composeIdentifier(t, "BodySite", "identifier", element.getIdentifier().get(i), i); 1851 if (element.hasActiveElement()) 1852 composeBoolean(t, "BodySite", "active", element.getActiveElement(), -1); 1853 if (element.hasCode()) 1854 composeCodeableConcept(t, "BodySite", "code", element.getCode(), -1); 1855 for (int i = 0; i < element.getQualifier().size(); i++) 1856 composeCodeableConcept(t, "BodySite", "qualifier", element.getQualifier().get(i), i); 1857 if (element.hasDescriptionElement()) 1858 composeString(t, "BodySite", "description", element.getDescriptionElement(), -1); 1859 for (int i = 0; i < element.getImage().size(); i++) 1860 composeAttachment(t, "BodySite", "image", element.getImage().get(i), i); 1861 if (element.hasPatient()) 1862 composeReference(t, "BodySite", "patient", element.getPatient(), -1); 1863 } 1864 1865 protected void composeBundle(Complex parent, String parentType, String name, Bundle element, int index) { 1866 if (element == null) 1867 return; 1868 Complex t; 1869 if (Utilities.noString(parentType)) 1870 t = parent; 1871 else { 1872 t = parent.predicate("fhir:"+parentType+'.'+name); 1873 } 1874 composeResource(t, "Bundle", name, element, index); 1875 if (element.hasIdentifier()) 1876 composeIdentifier(t, "Bundle", "identifier", element.getIdentifier(), -1); 1877 if (element.hasTypeElement()) 1878 composeEnum(t, "Bundle", "type", element.getTypeElement(), -1); 1879 if (element.hasTotalElement()) 1880 composeUnsignedInt(t, "Bundle", "total", element.getTotalElement(), -1); 1881 for (int i = 0; i < element.getLink().size(); i++) 1882 composeBundleBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i); 1883 for (int i = 0; i < element.getEntry().size(); i++) 1884 composeBundleBundleEntryComponent(t, "Bundle", "entry", element.getEntry().get(i), i); 1885 if (element.hasSignature()) 1886 composeSignature(t, "Bundle", "signature", element.getSignature(), -1); 1887 } 1888 1889 protected void composeBundleBundleLinkComponent(Complex parent, String parentType, String name, Bundle.BundleLinkComponent element, int index) { 1890 if (element == null) 1891 return; 1892 Complex t; 1893 if (Utilities.noString(parentType)) 1894 t = parent; 1895 else { 1896 t = parent.predicate("fhir:"+parentType+'.'+name); 1897 } 1898 composeBackboneElement(t, "link", name, element, index); 1899 if (element.hasRelationElement()) 1900 composeString(t, "Bundle", "relation", element.getRelationElement(), -1); 1901 if (element.hasUrlElement()) 1902 composeUri(t, "Bundle", "url", element.getUrlElement(), -1); 1903 } 1904 1905 protected void composeBundleBundleEntryComponent(Complex parent, String parentType, String name, Bundle.BundleEntryComponent element, int index) { 1906 if (element == null) 1907 return; 1908 Complex t; 1909 if (Utilities.noString(parentType)) 1910 t = parent; 1911 else { 1912 t = parent.predicate("fhir:"+parentType+'.'+name); 1913 } 1914 composeBackboneElement(t, "entry", name, element, index); 1915 for (int i = 0; i < element.getLink().size(); i++) 1916 composeBundleBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i); 1917 if (element.hasFullUrlElement()) 1918 composeUri(t, "Bundle", "fullUrl", element.getFullUrlElement(), -1); 1919 if (element.hasResource()) 1920 composeResource(t, "Bundle", "resource", element.getResource(), -1); 1921 if (element.hasSearch()) 1922 composeBundleBundleEntrySearchComponent(t, "Bundle", "search", element.getSearch(), -1); 1923 if (element.hasRequest()) 1924 composeBundleBundleEntryRequestComponent(t, "Bundle", "request", element.getRequest(), -1); 1925 if (element.hasResponse()) 1926 composeBundleBundleEntryResponseComponent(t, "Bundle", "response", element.getResponse(), -1); 1927 } 1928 1929 protected void composeBundleBundleEntrySearchComponent(Complex parent, String parentType, String name, Bundle.BundleEntrySearchComponent element, int index) { 1930 if (element == null) 1931 return; 1932 Complex t; 1933 if (Utilities.noString(parentType)) 1934 t = parent; 1935 else { 1936 t = parent.predicate("fhir:"+parentType+'.'+name); 1937 } 1938 composeBackboneElement(t, "search", name, element, index); 1939 if (element.hasModeElement()) 1940 composeEnum(t, "Bundle", "mode", element.getModeElement(), -1); 1941 if (element.hasScoreElement()) 1942 composeDecimal(t, "Bundle", "score", element.getScoreElement(), -1); 1943 } 1944 1945 protected void composeBundleBundleEntryRequestComponent(Complex parent, String parentType, String name, Bundle.BundleEntryRequestComponent element, int index) { 1946 if (element == null) 1947 return; 1948 Complex t; 1949 if (Utilities.noString(parentType)) 1950 t = parent; 1951 else { 1952 t = parent.predicate("fhir:"+parentType+'.'+name); 1953 } 1954 composeBackboneElement(t, "request", name, element, index); 1955 if (element.hasMethodElement()) 1956 composeEnum(t, "Bundle", "method", element.getMethodElement(), -1); 1957 if (element.hasUrlElement()) 1958 composeUri(t, "Bundle", "url", element.getUrlElement(), -1); 1959 if (element.hasIfNoneMatchElement()) 1960 composeString(t, "Bundle", "ifNoneMatch", element.getIfNoneMatchElement(), -1); 1961 if (element.hasIfModifiedSinceElement()) 1962 composeInstant(t, "Bundle", "ifModifiedSince", element.getIfModifiedSinceElement(), -1); 1963 if (element.hasIfMatchElement()) 1964 composeString(t, "Bundle", "ifMatch", element.getIfMatchElement(), -1); 1965 if (element.hasIfNoneExistElement()) 1966 composeString(t, "Bundle", "ifNoneExist", element.getIfNoneExistElement(), -1); 1967 } 1968 1969 protected void composeBundleBundleEntryResponseComponent(Complex parent, String parentType, String name, Bundle.BundleEntryResponseComponent element, int index) { 1970 if (element == null) 1971 return; 1972 Complex t; 1973 if (Utilities.noString(parentType)) 1974 t = parent; 1975 else { 1976 t = parent.predicate("fhir:"+parentType+'.'+name); 1977 } 1978 composeBackboneElement(t, "response", name, element, index); 1979 if (element.hasStatusElement()) 1980 composeString(t, "Bundle", "status", element.getStatusElement(), -1); 1981 if (element.hasLocationElement()) 1982 composeUri(t, "Bundle", "location", element.getLocationElement(), -1); 1983 if (element.hasEtagElement()) 1984 composeString(t, "Bundle", "etag", element.getEtagElement(), -1); 1985 if (element.hasLastModifiedElement()) 1986 composeInstant(t, "Bundle", "lastModified", element.getLastModifiedElement(), -1); 1987 if (element.hasOutcome()) 1988 composeResource(t, "Bundle", "outcome", element.getOutcome(), -1); 1989 } 1990 1991 protected void composeCapabilityStatement(Complex parent, String parentType, String name, CapabilityStatement element, int index) { 1992 if (element == null) 1993 return; 1994 Complex t; 1995 if (Utilities.noString(parentType)) 1996 t = parent; 1997 else { 1998 t = parent.predicate("fhir:"+parentType+'.'+name); 1999 } 2000 composeDomainResource(t, "CapabilityStatement", name, element, index); 2001 if (element.hasUrlElement()) 2002 composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1); 2003 if (element.hasVersionElement()) 2004 composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1); 2005 if (element.hasNameElement()) 2006 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2007 if (element.hasTitleElement()) 2008 composeString(t, "CapabilityStatement", "title", element.getTitleElement(), -1); 2009 if (element.hasStatusElement()) 2010 composeEnum(t, "CapabilityStatement", "status", element.getStatusElement(), -1); 2011 if (element.hasExperimentalElement()) 2012 composeBoolean(t, "CapabilityStatement", "experimental", element.getExperimentalElement(), -1); 2013 if (element.hasDateElement()) 2014 composeDateTime(t, "CapabilityStatement", "date", element.getDateElement(), -1); 2015 if (element.hasPublisherElement()) 2016 composeString(t, "CapabilityStatement", "publisher", element.getPublisherElement(), -1); 2017 for (int i = 0; i < element.getContact().size(); i++) 2018 composeContactDetail(t, "CapabilityStatement", "contact", element.getContact().get(i), i); 2019 if (element.hasDescriptionElement()) 2020 composeMarkdown(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1); 2021 for (int i = 0; i < element.getUseContext().size(); i++) 2022 composeUsageContext(t, "CapabilityStatement", "useContext", element.getUseContext().get(i), i); 2023 for (int i = 0; i < element.getJurisdiction().size(); i++) 2024 composeCodeableConcept(t, "CapabilityStatement", "jurisdiction", element.getJurisdiction().get(i), i); 2025 if (element.hasPurposeElement()) 2026 composeMarkdown(t, "CapabilityStatement", "purpose", element.getPurposeElement(), -1); 2027 if (element.hasCopyrightElement()) 2028 composeMarkdown(t, "CapabilityStatement", "copyright", element.getCopyrightElement(), -1); 2029 if (element.hasKindElement()) 2030 composeEnum(t, "CapabilityStatement", "kind", element.getKindElement(), -1); 2031 for (int i = 0; i < element.getInstantiates().size(); i++) 2032 composeUri(t, "CapabilityStatement", "instantiates", element.getInstantiates().get(i), i); 2033 if (element.hasSoftware()) 2034 composeCapabilityStatementCapabilityStatementSoftwareComponent(t, "CapabilityStatement", "software", element.getSoftware(), -1); 2035 if (element.hasImplementation()) 2036 composeCapabilityStatementCapabilityStatementImplementationComponent(t, "CapabilityStatement", "implementation", element.getImplementation(), -1); 2037 if (element.hasFhirVersionElement()) 2038 composeId(t, "CapabilityStatement", "fhirVersion", element.getFhirVersionElement(), -1); 2039 if (element.hasAcceptUnknownElement()) 2040 composeEnum(t, "CapabilityStatement", "acceptUnknown", element.getAcceptUnknownElement(), -1); 2041 for (int i = 0; i < element.getFormat().size(); i++) 2042 composeCode(t, "CapabilityStatement", "format", element.getFormat().get(i), i); 2043 for (int i = 0; i < element.getPatchFormat().size(); i++) 2044 composeCode(t, "CapabilityStatement", "patchFormat", element.getPatchFormat().get(i), i); 2045 for (int i = 0; i < element.getImplementationGuide().size(); i++) 2046 composeUri(t, "CapabilityStatement", "implementationGuide", element.getImplementationGuide().get(i), i); 2047 for (int i = 0; i < element.getProfile().size(); i++) 2048 composeReference(t, "CapabilityStatement", "profile", element.getProfile().get(i), i); 2049 for (int i = 0; i < element.getRest().size(); i++) 2050 composeCapabilityStatementCapabilityStatementRestComponent(t, "CapabilityStatement", "rest", element.getRest().get(i), i); 2051 for (int i = 0; i < element.getMessaging().size(); i++) 2052 composeCapabilityStatementCapabilityStatementMessagingComponent(t, "CapabilityStatement", "messaging", element.getMessaging().get(i), i); 2053 for (int i = 0; i < element.getDocument().size(); i++) 2054 composeCapabilityStatementCapabilityStatementDocumentComponent(t, "CapabilityStatement", "document", element.getDocument().get(i), i); 2055 } 2056 2057 protected void composeCapabilityStatementCapabilityStatementSoftwareComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementSoftwareComponent element, int index) { 2058 if (element == null) 2059 return; 2060 Complex t; 2061 if (Utilities.noString(parentType)) 2062 t = parent; 2063 else { 2064 t = parent.predicate("fhir:"+parentType+'.'+name); 2065 } 2066 composeBackboneElement(t, "software", name, element, index); 2067 if (element.hasNameElement()) 2068 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2069 if (element.hasVersionElement()) 2070 composeString(t, "CapabilityStatement", "version", element.getVersionElement(), -1); 2071 if (element.hasReleaseDateElement()) 2072 composeDateTime(t, "CapabilityStatement", "releaseDate", element.getReleaseDateElement(), -1); 2073 } 2074 2075 protected void composeCapabilityStatementCapabilityStatementImplementationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementImplementationComponent element, int index) { 2076 if (element == null) 2077 return; 2078 Complex t; 2079 if (Utilities.noString(parentType)) 2080 t = parent; 2081 else { 2082 t = parent.predicate("fhir:"+parentType+'.'+name); 2083 } 2084 composeBackboneElement(t, "implementation", name, element, index); 2085 if (element.hasDescriptionElement()) 2086 composeString(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1); 2087 if (element.hasUrlElement()) 2088 composeUri(t, "CapabilityStatement", "url", element.getUrlElement(), -1); 2089 } 2090 2091 protected void composeCapabilityStatementCapabilityStatementRestComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestComponent element, int index) { 2092 if (element == null) 2093 return; 2094 Complex t; 2095 if (Utilities.noString(parentType)) 2096 t = parent; 2097 else { 2098 t = parent.predicate("fhir:"+parentType+'.'+name); 2099 } 2100 composeBackboneElement(t, "rest", name, element, index); 2101 if (element.hasModeElement()) 2102 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2103 if (element.hasDocumentationElement()) 2104 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2105 if (element.hasSecurity()) 2106 composeCapabilityStatementCapabilityStatementRestSecurityComponent(t, "CapabilityStatement", "security", element.getSecurity(), -1); 2107 for (int i = 0; i < element.getResource().size(); i++) 2108 composeCapabilityStatementCapabilityStatementRestResourceComponent(t, "CapabilityStatement", "resource", element.getResource().get(i), i); 2109 for (int i = 0; i < element.getInteraction().size(); i++) 2110 composeCapabilityStatementSystemInteractionComponent(t, "CapabilityStatement", "interaction", element.getInteraction().get(i), i); 2111 for (int i = 0; i < element.getSearchParam().size(); i++) 2112 composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatement", "searchParam", element.getSearchParam().get(i), i); 2113 for (int i = 0; i < element.getOperation().size(); i++) 2114 composeCapabilityStatementCapabilityStatementRestOperationComponent(t, "CapabilityStatement", "operation", element.getOperation().get(i), i); 2115 for (int i = 0; i < element.getCompartment().size(); i++) 2116 composeUri(t, "CapabilityStatement", "compartment", element.getCompartment().get(i), i); 2117 } 2118 2119 protected void composeCapabilityStatementCapabilityStatementRestSecurityComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityComponent element, int index) { 2120 if (element == null) 2121 return; 2122 Complex t; 2123 if (Utilities.noString(parentType)) 2124 t = parent; 2125 else { 2126 t = parent.predicate("fhir:"+parentType+'.'+name); 2127 } 2128 composeBackboneElement(t, "security", name, element, index); 2129 if (element.hasCorsElement()) 2130 composeBoolean(t, "CapabilityStatement", "cors", element.getCorsElement(), -1); 2131 for (int i = 0; i < element.getService().size(); i++) 2132 composeCodeableConcept(t, "CapabilityStatement", "service", element.getService().get(i), i); 2133 if (element.hasDescriptionElement()) 2134 composeString(t, "CapabilityStatement", "description", element.getDescriptionElement(), -1); 2135 for (int i = 0; i < element.getCertificate().size(); i++) 2136 composeCapabilityStatementCapabilityStatementRestSecurityCertificateComponent(t, "CapabilityStatement", "certificate", element.getCertificate().get(i), i); 2137 } 2138 2139 protected void composeCapabilityStatementCapabilityStatementRestSecurityCertificateComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestSecurityCertificateComponent element, int index) { 2140 if (element == null) 2141 return; 2142 Complex t; 2143 if (Utilities.noString(parentType)) 2144 t = parent; 2145 else { 2146 t = parent.predicate("fhir:"+parentType+'.'+name); 2147 } 2148 composeBackboneElement(t, "certificate", name, element, index); 2149 if (element.hasTypeElement()) 2150 composeCode(t, "CapabilityStatement", "type", element.getTypeElement(), -1); 2151 if (element.hasBlobElement()) 2152 composeBase64Binary(t, "CapabilityStatement", "blob", element.getBlobElement(), -1); 2153 } 2154 2155 protected void composeCapabilityStatementCapabilityStatementRestResourceComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceComponent element, int index) { 2156 if (element == null) 2157 return; 2158 Complex t; 2159 if (Utilities.noString(parentType)) 2160 t = parent; 2161 else { 2162 t = parent.predicate("fhir:"+parentType+'.'+name); 2163 } 2164 composeBackboneElement(t, "resource", name, element, index); 2165 if (element.hasTypeElement()) 2166 composeCode(t, "CapabilityStatement", "type", element.getTypeElement(), -1); 2167 if (element.hasProfile()) 2168 composeReference(t, "CapabilityStatement", "profile", element.getProfile(), -1); 2169 if (element.hasDocumentationElement()) 2170 composeMarkdown(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2171 for (int i = 0; i < element.getInteraction().size(); i++) 2172 composeCapabilityStatementResourceInteractionComponent(t, "CapabilityStatement", "interaction", element.getInteraction().get(i), i); 2173 if (element.hasVersioningElement()) 2174 composeEnum(t, "CapabilityStatement", "versioning", element.getVersioningElement(), -1); 2175 if (element.hasReadHistoryElement()) 2176 composeBoolean(t, "CapabilityStatement", "readHistory", element.getReadHistoryElement(), -1); 2177 if (element.hasUpdateCreateElement()) 2178 composeBoolean(t, "CapabilityStatement", "updateCreate", element.getUpdateCreateElement(), -1); 2179 if (element.hasConditionalCreateElement()) 2180 composeBoolean(t, "CapabilityStatement", "conditionalCreate", element.getConditionalCreateElement(), -1); 2181 if (element.hasConditionalReadElement()) 2182 composeEnum(t, "CapabilityStatement", "conditionalRead", element.getConditionalReadElement(), -1); 2183 if (element.hasConditionalUpdateElement()) 2184 composeBoolean(t, "CapabilityStatement", "conditionalUpdate", element.getConditionalUpdateElement(), -1); 2185 if (element.hasConditionalDeleteElement()) 2186 composeEnum(t, "CapabilityStatement", "conditionalDelete", element.getConditionalDeleteElement(), -1); 2187 for (int i = 0; i < element.getReferencePolicy().size(); i++) 2188 composeEnum(t, "CapabilityStatement", "referencePolicy", element.getReferencePolicy().get(i), i); 2189 for (int i = 0; i < element.getSearchInclude().size(); i++) 2190 composeString(t, "CapabilityStatement", "searchInclude", element.getSearchInclude().get(i), i); 2191 for (int i = 0; i < element.getSearchRevInclude().size(); i++) 2192 composeString(t, "CapabilityStatement", "searchRevInclude", element.getSearchRevInclude().get(i), i); 2193 for (int i = 0; i < element.getSearchParam().size(); i++) 2194 composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(t, "CapabilityStatement", "searchParam", element.getSearchParam().get(i), i); 2195 } 2196 2197 protected void composeCapabilityStatementResourceInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.ResourceInteractionComponent element, int index) { 2198 if (element == null) 2199 return; 2200 Complex t; 2201 if (Utilities.noString(parentType)) 2202 t = parent; 2203 else { 2204 t = parent.predicate("fhir:"+parentType+'.'+name); 2205 } 2206 composeBackboneElement(t, "interaction", name, element, index); 2207 if (element.hasCodeElement()) 2208 composeEnum(t, "CapabilityStatement", "code", element.getCodeElement(), -1); 2209 if (element.hasDocumentationElement()) 2210 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2211 } 2212 2213 protected void composeCapabilityStatementCapabilityStatementRestResourceSearchParamComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent element, int index) { 2214 if (element == null) 2215 return; 2216 Complex t; 2217 if (Utilities.noString(parentType)) 2218 t = parent; 2219 else { 2220 t = parent.predicate("fhir:"+parentType+'.'+name); 2221 } 2222 composeBackboneElement(t, "searchParam", name, element, index); 2223 if (element.hasNameElement()) 2224 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2225 if (element.hasDefinitionElement()) 2226 composeUri(t, "CapabilityStatement", "definition", element.getDefinitionElement(), -1); 2227 if (element.hasTypeElement()) 2228 composeEnum(t, "CapabilityStatement", "type", element.getTypeElement(), -1); 2229 if (element.hasDocumentationElement()) 2230 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2231 } 2232 2233 protected void composeCapabilityStatementSystemInteractionComponent(Complex parent, String parentType, String name, CapabilityStatement.SystemInteractionComponent element, int index) { 2234 if (element == null) 2235 return; 2236 Complex t; 2237 if (Utilities.noString(parentType)) 2238 t = parent; 2239 else { 2240 t = parent.predicate("fhir:"+parentType+'.'+name); 2241 } 2242 composeBackboneElement(t, "interaction", name, element, index); 2243 if (element.hasCodeElement()) 2244 composeEnum(t, "CapabilityStatement", "code", element.getCodeElement(), -1); 2245 if (element.hasDocumentationElement()) 2246 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2247 } 2248 2249 protected void composeCapabilityStatementCapabilityStatementRestOperationComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementRestOperationComponent element, int index) { 2250 if (element == null) 2251 return; 2252 Complex t; 2253 if (Utilities.noString(parentType)) 2254 t = parent; 2255 else { 2256 t = parent.predicate("fhir:"+parentType+'.'+name); 2257 } 2258 composeBackboneElement(t, "operation", name, element, index); 2259 if (element.hasNameElement()) 2260 composeString(t, "CapabilityStatement", "name", element.getNameElement(), -1); 2261 if (element.hasDefinition()) 2262 composeReference(t, "CapabilityStatement", "definition", element.getDefinition(), -1); 2263 } 2264 2265 protected void composeCapabilityStatementCapabilityStatementMessagingComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingComponent element, int index) { 2266 if (element == null) 2267 return; 2268 Complex t; 2269 if (Utilities.noString(parentType)) 2270 t = parent; 2271 else { 2272 t = parent.predicate("fhir:"+parentType+'.'+name); 2273 } 2274 composeBackboneElement(t, "messaging", name, element, index); 2275 for (int i = 0; i < element.getEndpoint().size(); i++) 2276 composeCapabilityStatementCapabilityStatementMessagingEndpointComponent(t, "CapabilityStatement", "endpoint", element.getEndpoint().get(i), i); 2277 if (element.hasReliableCacheElement()) 2278 composeUnsignedInt(t, "CapabilityStatement", "reliableCache", element.getReliableCacheElement(), -1); 2279 if (element.hasDocumentationElement()) 2280 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2281 for (int i = 0; i < element.getSupportedMessage().size(); i++) 2282 composeCapabilityStatementCapabilityStatementMessagingSupportedMessageComponent(t, "CapabilityStatement", "supportedMessage", element.getSupportedMessage().get(i), i); 2283 for (int i = 0; i < element.getEvent().size(); i++) 2284 composeCapabilityStatementCapabilityStatementMessagingEventComponent(t, "CapabilityStatement", "event", element.getEvent().get(i), i); 2285 } 2286 2287 protected void composeCapabilityStatementCapabilityStatementMessagingEndpointComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEndpointComponent element, int index) { 2288 if (element == null) 2289 return; 2290 Complex t; 2291 if (Utilities.noString(parentType)) 2292 t = parent; 2293 else { 2294 t = parent.predicate("fhir:"+parentType+'.'+name); 2295 } 2296 composeBackboneElement(t, "endpoint", name, element, index); 2297 if (element.hasProtocol()) 2298 composeCoding(t, "CapabilityStatement", "protocol", element.getProtocol(), -1); 2299 if (element.hasAddressElement()) 2300 composeUri(t, "CapabilityStatement", "address", element.getAddressElement(), -1); 2301 } 2302 2303 protected void composeCapabilityStatementCapabilityStatementMessagingSupportedMessageComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent element, int index) { 2304 if (element == null) 2305 return; 2306 Complex t; 2307 if (Utilities.noString(parentType)) 2308 t = parent; 2309 else { 2310 t = parent.predicate("fhir:"+parentType+'.'+name); 2311 } 2312 composeBackboneElement(t, "supportedMessage", name, element, index); 2313 if (element.hasModeElement()) 2314 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2315 if (element.hasDefinition()) 2316 composeReference(t, "CapabilityStatement", "definition", element.getDefinition(), -1); 2317 } 2318 2319 protected void composeCapabilityStatementCapabilityStatementMessagingEventComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementMessagingEventComponent element, int index) { 2320 if (element == null) 2321 return; 2322 Complex t; 2323 if (Utilities.noString(parentType)) 2324 t = parent; 2325 else { 2326 t = parent.predicate("fhir:"+parentType+'.'+name); 2327 } 2328 composeBackboneElement(t, "event", name, element, index); 2329 if (element.hasCode()) 2330 composeCoding(t, "CapabilityStatement", "code", element.getCode(), -1); 2331 if (element.hasCategoryElement()) 2332 composeEnum(t, "CapabilityStatement", "category", element.getCategoryElement(), -1); 2333 if (element.hasModeElement()) 2334 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2335 if (element.hasFocusElement()) 2336 composeCode(t, "CapabilityStatement", "focus", element.getFocusElement(), -1); 2337 if (element.hasRequest()) 2338 composeReference(t, "CapabilityStatement", "request", element.getRequest(), -1); 2339 if (element.hasResponse()) 2340 composeReference(t, "CapabilityStatement", "response", element.getResponse(), -1); 2341 if (element.hasDocumentationElement()) 2342 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2343 } 2344 2345 protected void composeCapabilityStatementCapabilityStatementDocumentComponent(Complex parent, String parentType, String name, CapabilityStatement.CapabilityStatementDocumentComponent element, int index) { 2346 if (element == null) 2347 return; 2348 Complex t; 2349 if (Utilities.noString(parentType)) 2350 t = parent; 2351 else { 2352 t = parent.predicate("fhir:"+parentType+'.'+name); 2353 } 2354 composeBackboneElement(t, "document", name, element, index); 2355 if (element.hasModeElement()) 2356 composeEnum(t, "CapabilityStatement", "mode", element.getModeElement(), -1); 2357 if (element.hasDocumentationElement()) 2358 composeString(t, "CapabilityStatement", "documentation", element.getDocumentationElement(), -1); 2359 if (element.hasProfile()) 2360 composeReference(t, "CapabilityStatement", "profile", element.getProfile(), -1); 2361 } 2362 2363 protected void composeCarePlan(Complex parent, String parentType, String name, CarePlan element, int index) { 2364 if (element == null) 2365 return; 2366 Complex t; 2367 if (Utilities.noString(parentType)) 2368 t = parent; 2369 else { 2370 t = parent.predicate("fhir:"+parentType+'.'+name); 2371 } 2372 composeDomainResource(t, "CarePlan", name, element, index); 2373 for (int i = 0; i < element.getIdentifier().size(); i++) 2374 composeIdentifier(t, "CarePlan", "identifier", element.getIdentifier().get(i), i); 2375 for (int i = 0; i < element.getDefinition().size(); i++) 2376 composeReference(t, "CarePlan", "definition", element.getDefinition().get(i), i); 2377 for (int i = 0; i < element.getBasedOn().size(); i++) 2378 composeReference(t, "CarePlan", "basedOn", element.getBasedOn().get(i), i); 2379 for (int i = 0; i < element.getReplaces().size(); i++) 2380 composeReference(t, "CarePlan", "replaces", element.getReplaces().get(i), i); 2381 for (int i = 0; i < element.getPartOf().size(); i++) 2382 composeReference(t, "CarePlan", "partOf", element.getPartOf().get(i), i); 2383 if (element.hasStatusElement()) 2384 composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1); 2385 if (element.hasIntentElement()) 2386 composeEnum(t, "CarePlan", "intent", element.getIntentElement(), -1); 2387 for (int i = 0; i < element.getCategory().size(); i++) 2388 composeCodeableConcept(t, "CarePlan", "category", element.getCategory().get(i), i); 2389 if (element.hasTitleElement()) 2390 composeString(t, "CarePlan", "title", element.getTitleElement(), -1); 2391 if (element.hasDescriptionElement()) 2392 composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1); 2393 if (element.hasSubject()) 2394 composeReference(t, "CarePlan", "subject", element.getSubject(), -1); 2395 if (element.hasContext()) 2396 composeReference(t, "CarePlan", "context", element.getContext(), -1); 2397 if (element.hasPeriod()) 2398 composePeriod(t, "CarePlan", "period", element.getPeriod(), -1); 2399 for (int i = 0; i < element.getAuthor().size(); i++) 2400 composeReference(t, "CarePlan", "author", element.getAuthor().get(i), i); 2401 for (int i = 0; i < element.getCareTeam().size(); i++) 2402 composeReference(t, "CarePlan", "careTeam", element.getCareTeam().get(i), i); 2403 for (int i = 0; i < element.getAddresses().size(); i++) 2404 composeReference(t, "CarePlan", "addresses", element.getAddresses().get(i), i); 2405 for (int i = 0; i < element.getSupportingInfo().size(); i++) 2406 composeReference(t, "CarePlan", "supportingInfo", element.getSupportingInfo().get(i), i); 2407 for (int i = 0; i < element.getGoal().size(); i++) 2408 composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i); 2409 for (int i = 0; i < element.getActivity().size(); i++) 2410 composeCarePlanCarePlanActivityComponent(t, "CarePlan", "activity", element.getActivity().get(i), i); 2411 for (int i = 0; i < element.getNote().size(); i++) 2412 composeAnnotation(t, "CarePlan", "note", element.getNote().get(i), i); 2413 } 2414 2415 protected void composeCarePlanCarePlanActivityComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityComponent element, int index) { 2416 if (element == null) 2417 return; 2418 Complex t; 2419 if (Utilities.noString(parentType)) 2420 t = parent; 2421 else { 2422 t = parent.predicate("fhir:"+parentType+'.'+name); 2423 } 2424 composeBackboneElement(t, "activity", name, element, index); 2425 for (int i = 0; i < element.getOutcomeCodeableConcept().size(); i++) 2426 composeCodeableConcept(t, "CarePlan", "outcomeCodeableConcept", element.getOutcomeCodeableConcept().get(i), i); 2427 for (int i = 0; i < element.getOutcomeReference().size(); i++) 2428 composeReference(t, "CarePlan", "outcomeReference", element.getOutcomeReference().get(i), i); 2429 for (int i = 0; i < element.getProgress().size(); i++) 2430 composeAnnotation(t, "CarePlan", "progress", element.getProgress().get(i), i); 2431 if (element.hasReference()) 2432 composeReference(t, "CarePlan", "reference", element.getReference(), -1); 2433 if (element.hasDetail()) 2434 composeCarePlanCarePlanActivityDetailComponent(t, "CarePlan", "detail", element.getDetail(), -1); 2435 } 2436 2437 protected void composeCarePlanCarePlanActivityDetailComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityDetailComponent element, int index) { 2438 if (element == null) 2439 return; 2440 Complex t; 2441 if (Utilities.noString(parentType)) 2442 t = parent; 2443 else { 2444 t = parent.predicate("fhir:"+parentType+'.'+name); 2445 } 2446 composeBackboneElement(t, "detail", name, element, index); 2447 if (element.hasCategory()) 2448 composeCodeableConcept(t, "CarePlan", "category", element.getCategory(), -1); 2449 if (element.hasDefinition()) 2450 composeReference(t, "CarePlan", "definition", element.getDefinition(), -1); 2451 if (element.hasCode()) 2452 composeCodeableConcept(t, "CarePlan", "code", element.getCode(), -1); 2453 for (int i = 0; i < element.getReasonCode().size(); i++) 2454 composeCodeableConcept(t, "CarePlan", "reasonCode", element.getReasonCode().get(i), i); 2455 for (int i = 0; i < element.getReasonReference().size(); i++) 2456 composeReference(t, "CarePlan", "reasonReference", element.getReasonReference().get(i), i); 2457 for (int i = 0; i < element.getGoal().size(); i++) 2458 composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i); 2459 if (element.hasStatusElement()) 2460 composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1); 2461 if (element.hasStatusReasonElement()) 2462 composeString(t, "CarePlan", "statusReason", element.getStatusReasonElement(), -1); 2463 if (element.hasProhibitedElement()) 2464 composeBoolean(t, "CarePlan", "prohibited", element.getProhibitedElement(), -1); 2465 if (element.hasScheduled()) 2466 composeType(t, "CarePlan", "scheduled", element.getScheduled(), -1); 2467 if (element.hasLocation()) 2468 composeReference(t, "CarePlan", "location", element.getLocation(), -1); 2469 for (int i = 0; i < element.getPerformer().size(); i++) 2470 composeReference(t, "CarePlan", "performer", element.getPerformer().get(i), i); 2471 if (element.hasProduct()) 2472 composeType(t, "CarePlan", "product", element.getProduct(), -1); 2473 if (element.hasDailyAmount()) 2474 composeQuantity(t, "CarePlan", "dailyAmount", element.getDailyAmount(), -1); 2475 if (element.hasQuantity()) 2476 composeQuantity(t, "CarePlan", "quantity", element.getQuantity(), -1); 2477 if (element.hasDescriptionElement()) 2478 composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1); 2479 } 2480 2481 protected void composeCareTeam(Complex parent, String parentType, String name, CareTeam element, int index) { 2482 if (element == null) 2483 return; 2484 Complex t; 2485 if (Utilities.noString(parentType)) 2486 t = parent; 2487 else { 2488 t = parent.predicate("fhir:"+parentType+'.'+name); 2489 } 2490 composeDomainResource(t, "CareTeam", name, element, index); 2491 for (int i = 0; i < element.getIdentifier().size(); i++) 2492 composeIdentifier(t, "CareTeam", "identifier", element.getIdentifier().get(i), i); 2493 if (element.hasStatusElement()) 2494 composeEnum(t, "CareTeam", "status", element.getStatusElement(), -1); 2495 for (int i = 0; i < element.getCategory().size(); i++) 2496 composeCodeableConcept(t, "CareTeam", "category", element.getCategory().get(i), i); 2497 if (element.hasNameElement()) 2498 composeString(t, "CareTeam", "name", element.getNameElement(), -1); 2499 if (element.hasSubject()) 2500 composeReference(t, "CareTeam", "subject", element.getSubject(), -1); 2501 if (element.hasContext()) 2502 composeReference(t, "CareTeam", "context", element.getContext(), -1); 2503 if (element.hasPeriod()) 2504 composePeriod(t, "CareTeam", "period", element.getPeriod(), -1); 2505 for (int i = 0; i < element.getParticipant().size(); i++) 2506 composeCareTeamCareTeamParticipantComponent(t, "CareTeam", "participant", element.getParticipant().get(i), i); 2507 for (int i = 0; i < element.getReasonCode().size(); i++) 2508 composeCodeableConcept(t, "CareTeam", "reasonCode", element.getReasonCode().get(i), i); 2509 for (int i = 0; i < element.getReasonReference().size(); i++) 2510 composeReference(t, "CareTeam", "reasonReference", element.getReasonReference().get(i), i); 2511 for (int i = 0; i < element.getManagingOrganization().size(); i++) 2512 composeReference(t, "CareTeam", "managingOrganization", element.getManagingOrganization().get(i), i); 2513 for (int i = 0; i < element.getNote().size(); i++) 2514 composeAnnotation(t, "CareTeam", "note", element.getNote().get(i), i); 2515 } 2516 2517 protected void composeCareTeamCareTeamParticipantComponent(Complex parent, String parentType, String name, CareTeam.CareTeamParticipantComponent element, int index) { 2518 if (element == null) 2519 return; 2520 Complex t; 2521 if (Utilities.noString(parentType)) 2522 t = parent; 2523 else { 2524 t = parent.predicate("fhir:"+parentType+'.'+name); 2525 } 2526 composeBackboneElement(t, "participant", name, element, index); 2527 if (element.hasRole()) 2528 composeCodeableConcept(t, "CareTeam", "role", element.getRole(), -1); 2529 if (element.hasMember()) 2530 composeReference(t, "CareTeam", "member", element.getMember(), -1); 2531 if (element.hasOnBehalfOf()) 2532 composeReference(t, "CareTeam", "onBehalfOf", element.getOnBehalfOf(), -1); 2533 if (element.hasPeriod()) 2534 composePeriod(t, "CareTeam", "period", element.getPeriod(), -1); 2535 } 2536 2537 protected void composeChargeItem(Complex parent, String parentType, String name, ChargeItem element, int index) { 2538 if (element == null) 2539 return; 2540 Complex t; 2541 if (Utilities.noString(parentType)) 2542 t = parent; 2543 else { 2544 t = parent.predicate("fhir:"+parentType+'.'+name); 2545 } 2546 composeDomainResource(t, "ChargeItem", name, element, index); 2547 if (element.hasIdentifier()) 2548 composeIdentifier(t, "ChargeItem", "identifier", element.getIdentifier(), -1); 2549 for (int i = 0; i < element.getDefinition().size(); i++) 2550 composeUri(t, "ChargeItem", "definition", element.getDefinition().get(i), i); 2551 if (element.hasStatusElement()) 2552 composeEnum(t, "ChargeItem", "status", element.getStatusElement(), -1); 2553 for (int i = 0; i < element.getPartOf().size(); i++) 2554 composeReference(t, "ChargeItem", "partOf", element.getPartOf().get(i), i); 2555 if (element.hasCode()) 2556 composeCodeableConcept(t, "ChargeItem", "code", element.getCode(), -1); 2557 if (element.hasSubject()) 2558 composeReference(t, "ChargeItem", "subject", element.getSubject(), -1); 2559 if (element.hasContext()) 2560 composeReference(t, "ChargeItem", "context", element.getContext(), -1); 2561 if (element.hasOccurrence()) 2562 composeType(t, "ChargeItem", "occurrence", element.getOccurrence(), -1); 2563 for (int i = 0; i < element.getParticipant().size(); i++) 2564 composeChargeItemChargeItemParticipantComponent(t, "ChargeItem", "participant", element.getParticipant().get(i), i); 2565 if (element.hasPerformingOrganization()) 2566 composeReference(t, "ChargeItem", "performingOrganization", element.getPerformingOrganization(), -1); 2567 if (element.hasRequestingOrganization()) 2568 composeReference(t, "ChargeItem", "requestingOrganization", element.getRequestingOrganization(), -1); 2569 if (element.hasQuantity()) 2570 composeQuantity(t, "ChargeItem", "quantity", element.getQuantity(), -1); 2571 for (int i = 0; i < element.getBodysite().size(); i++) 2572 composeCodeableConcept(t, "ChargeItem", "bodysite", element.getBodysite().get(i), i); 2573 if (element.hasFactorOverrideElement()) 2574 composeDecimal(t, "ChargeItem", "factorOverride", element.getFactorOverrideElement(), -1); 2575 if (element.hasPriceOverride()) 2576 composeMoney(t, "ChargeItem", "priceOverride", element.getPriceOverride(), -1); 2577 if (element.hasOverrideReasonElement()) 2578 composeString(t, "ChargeItem", "overrideReason", element.getOverrideReasonElement(), -1); 2579 if (element.hasEnterer()) 2580 composeReference(t, "ChargeItem", "enterer", element.getEnterer(), -1); 2581 if (element.hasEnteredDateElement()) 2582 composeDateTime(t, "ChargeItem", "enteredDate", element.getEnteredDateElement(), -1); 2583 for (int i = 0; i < element.getReason().size(); i++) 2584 composeCodeableConcept(t, "ChargeItem", "reason", element.getReason().get(i), i); 2585 for (int i = 0; i < element.getService().size(); i++) 2586 composeReference(t, "ChargeItem", "service", element.getService().get(i), i); 2587 for (int i = 0; i < element.getAccount().size(); i++) 2588 composeReference(t, "ChargeItem", "account", element.getAccount().get(i), i); 2589 for (int i = 0; i < element.getNote().size(); i++) 2590 composeAnnotation(t, "ChargeItem", "note", element.getNote().get(i), i); 2591 for (int i = 0; i < element.getSupportingInformation().size(); i++) 2592 composeReference(t, "ChargeItem", "supportingInformation", element.getSupportingInformation().get(i), i); 2593 } 2594 2595 protected void composeChargeItemChargeItemParticipantComponent(Complex parent, String parentType, String name, ChargeItem.ChargeItemParticipantComponent element, int index) { 2596 if (element == null) 2597 return; 2598 Complex t; 2599 if (Utilities.noString(parentType)) 2600 t = parent; 2601 else { 2602 t = parent.predicate("fhir:"+parentType+'.'+name); 2603 } 2604 composeBackboneElement(t, "participant", name, element, index); 2605 if (element.hasRole()) 2606 composeCodeableConcept(t, "ChargeItem", "role", element.getRole(), -1); 2607 if (element.hasActor()) 2608 composeReference(t, "ChargeItem", "actor", element.getActor(), -1); 2609 } 2610 2611 protected void composeClaim(Complex parent, String parentType, String name, Claim element, int index) { 2612 if (element == null) 2613 return; 2614 Complex t; 2615 if (Utilities.noString(parentType)) 2616 t = parent; 2617 else { 2618 t = parent.predicate("fhir:"+parentType+'.'+name); 2619 } 2620 composeDomainResource(t, "Claim", name, element, index); 2621 for (int i = 0; i < element.getIdentifier().size(); i++) 2622 composeIdentifier(t, "Claim", "identifier", element.getIdentifier().get(i), i); 2623 if (element.hasStatusElement()) 2624 composeEnum(t, "Claim", "status", element.getStatusElement(), -1); 2625 if (element.hasType()) 2626 composeCodeableConcept(t, "Claim", "type", element.getType(), -1); 2627 for (int i = 0; i < element.getSubType().size(); i++) 2628 composeCodeableConcept(t, "Claim", "subType", element.getSubType().get(i), i); 2629 if (element.hasUseElement()) 2630 composeEnum(t, "Claim", "use", element.getUseElement(), -1); 2631 if (element.hasPatient()) 2632 composeReference(t, "Claim", "patient", element.getPatient(), -1); 2633 if (element.hasBillablePeriod()) 2634 composePeriod(t, "Claim", "billablePeriod", element.getBillablePeriod(), -1); 2635 if (element.hasCreatedElement()) 2636 composeDateTime(t, "Claim", "created", element.getCreatedElement(), -1); 2637 if (element.hasEnterer()) 2638 composeReference(t, "Claim", "enterer", element.getEnterer(), -1); 2639 if (element.hasInsurer()) 2640 composeReference(t, "Claim", "insurer", element.getInsurer(), -1); 2641 if (element.hasProvider()) 2642 composeReference(t, "Claim", "provider", element.getProvider(), -1); 2643 if (element.hasOrganization()) 2644 composeReference(t, "Claim", "organization", element.getOrganization(), -1); 2645 if (element.hasPriority()) 2646 composeCodeableConcept(t, "Claim", "priority", element.getPriority(), -1); 2647 if (element.hasFundsReserve()) 2648 composeCodeableConcept(t, "Claim", "fundsReserve", element.getFundsReserve(), -1); 2649 for (int i = 0; i < element.getRelated().size(); i++) 2650 composeClaimRelatedClaimComponent(t, "Claim", "related", element.getRelated().get(i), i); 2651 if (element.hasPrescription()) 2652 composeReference(t, "Claim", "prescription", element.getPrescription(), -1); 2653 if (element.hasOriginalPrescription()) 2654 composeReference(t, "Claim", "originalPrescription", element.getOriginalPrescription(), -1); 2655 if (element.hasPayee()) 2656 composeClaimPayeeComponent(t, "Claim", "payee", element.getPayee(), -1); 2657 if (element.hasReferral()) 2658 composeReference(t, "Claim", "referral", element.getReferral(), -1); 2659 if (element.hasFacility()) 2660 composeReference(t, "Claim", "facility", element.getFacility(), -1); 2661 for (int i = 0; i < element.getCareTeam().size(); i++) 2662 composeClaimCareTeamComponent(t, "Claim", "careTeam", element.getCareTeam().get(i), i); 2663 for (int i = 0; i < element.getInformation().size(); i++) 2664 composeClaimSpecialConditionComponent(t, "Claim", "information", element.getInformation().get(i), i); 2665 for (int i = 0; i < element.getDiagnosis().size(); i++) 2666 composeClaimDiagnosisComponent(t, "Claim", "diagnosis", element.getDiagnosis().get(i), i); 2667 for (int i = 0; i < element.getProcedure().size(); i++) 2668 composeClaimProcedureComponent(t, "Claim", "procedure", element.getProcedure().get(i), i); 2669 for (int i = 0; i < element.getInsurance().size(); i++) 2670 composeClaimInsuranceComponent(t, "Claim", "insurance", element.getInsurance().get(i), i); 2671 if (element.hasAccident()) 2672 composeClaimAccidentComponent(t, "Claim", "accident", element.getAccident(), -1); 2673 if (element.hasEmploymentImpacted()) 2674 composePeriod(t, "Claim", "employmentImpacted", element.getEmploymentImpacted(), -1); 2675 if (element.hasHospitalization()) 2676 composePeriod(t, "Claim", "hospitalization", element.getHospitalization(), -1); 2677 for (int i = 0; i < element.getItem().size(); i++) 2678 composeClaimItemComponent(t, "Claim", "item", element.getItem().get(i), i); 2679 if (element.hasTotal()) 2680 composeMoney(t, "Claim", "total", element.getTotal(), -1); 2681 } 2682 2683 protected void composeClaimRelatedClaimComponent(Complex parent, String parentType, String name, Claim.RelatedClaimComponent element, int index) { 2684 if (element == null) 2685 return; 2686 Complex t; 2687 if (Utilities.noString(parentType)) 2688 t = parent; 2689 else { 2690 t = parent.predicate("fhir:"+parentType+'.'+name); 2691 } 2692 composeBackboneElement(t, "related", name, element, index); 2693 if (element.hasClaim()) 2694 composeReference(t, "Claim", "claim", element.getClaim(), -1); 2695 if (element.hasRelationship()) 2696 composeCodeableConcept(t, "Claim", "relationship", element.getRelationship(), -1); 2697 if (element.hasReference()) 2698 composeIdentifier(t, "Claim", "reference", element.getReference(), -1); 2699 } 2700 2701 protected void composeClaimPayeeComponent(Complex parent, String parentType, String name, Claim.PayeeComponent element, int index) { 2702 if (element == null) 2703 return; 2704 Complex t; 2705 if (Utilities.noString(parentType)) 2706 t = parent; 2707 else { 2708 t = parent.predicate("fhir:"+parentType+'.'+name); 2709 } 2710 composeBackboneElement(t, "payee", name, element, index); 2711 if (element.hasType()) 2712 composeCodeableConcept(t, "Claim", "type", element.getType(), -1); 2713 if (element.hasResourceType()) 2714 composeCoding(t, "Claim", "resourceType", element.getResourceType(), -1); 2715 if (element.hasParty()) 2716 composeReference(t, "Claim", "party", element.getParty(), -1); 2717 } 2718 2719 protected void composeClaimCareTeamComponent(Complex parent, String parentType, String name, Claim.CareTeamComponent element, int index) { 2720 if (element == null) 2721 return; 2722 Complex t; 2723 if (Utilities.noString(parentType)) 2724 t = parent; 2725 else { 2726 t = parent.predicate("fhir:"+parentType+'.'+name); 2727 } 2728 composeBackboneElement(t, "careTeam", name, element, index); 2729 if (element.hasSequenceElement()) 2730 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2731 if (element.hasProvider()) 2732 composeReference(t, "Claim", "provider", element.getProvider(), -1); 2733 if (element.hasResponsibleElement()) 2734 composeBoolean(t, "Claim", "responsible", element.getResponsibleElement(), -1); 2735 if (element.hasRole()) 2736 composeCodeableConcept(t, "Claim", "role", element.getRole(), -1); 2737 if (element.hasQualification()) 2738 composeCodeableConcept(t, "Claim", "qualification", element.getQualification(), -1); 2739 } 2740 2741 protected void composeClaimSpecialConditionComponent(Complex parent, String parentType, String name, Claim.SpecialConditionComponent element, int index) { 2742 if (element == null) 2743 return; 2744 Complex t; 2745 if (Utilities.noString(parentType)) 2746 t = parent; 2747 else { 2748 t = parent.predicate("fhir:"+parentType+'.'+name); 2749 } 2750 composeBackboneElement(t, "information", name, element, index); 2751 if (element.hasSequenceElement()) 2752 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2753 if (element.hasCategory()) 2754 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 2755 if (element.hasCode()) 2756 composeCodeableConcept(t, "Claim", "code", element.getCode(), -1); 2757 if (element.hasTiming()) 2758 composeType(t, "Claim", "timing", element.getTiming(), -1); 2759 if (element.hasValue()) 2760 composeType(t, "Claim", "value", element.getValue(), -1); 2761 if (element.hasReason()) 2762 composeCodeableConcept(t, "Claim", "reason", element.getReason(), -1); 2763 } 2764 2765 protected void composeClaimDiagnosisComponent(Complex parent, String parentType, String name, Claim.DiagnosisComponent element, int index) { 2766 if (element == null) 2767 return; 2768 Complex t; 2769 if (Utilities.noString(parentType)) 2770 t = parent; 2771 else { 2772 t = parent.predicate("fhir:"+parentType+'.'+name); 2773 } 2774 composeBackboneElement(t, "diagnosis", name, element, index); 2775 if (element.hasSequenceElement()) 2776 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2777 if (element.hasDiagnosis()) 2778 composeType(t, "Claim", "diagnosis", element.getDiagnosis(), -1); 2779 for (int i = 0; i < element.getType().size(); i++) 2780 composeCodeableConcept(t, "Claim", "type", element.getType().get(i), i); 2781 if (element.hasPackageCode()) 2782 composeCodeableConcept(t, "Claim", "packageCode", element.getPackageCode(), -1); 2783 } 2784 2785 protected void composeClaimProcedureComponent(Complex parent, String parentType, String name, Claim.ProcedureComponent element, int index) { 2786 if (element == null) 2787 return; 2788 Complex t; 2789 if (Utilities.noString(parentType)) 2790 t = parent; 2791 else { 2792 t = parent.predicate("fhir:"+parentType+'.'+name); 2793 } 2794 composeBackboneElement(t, "procedure", name, element, index); 2795 if (element.hasSequenceElement()) 2796 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2797 if (element.hasDateElement()) 2798 composeDateTime(t, "Claim", "date", element.getDateElement(), -1); 2799 if (element.hasProcedure()) 2800 composeType(t, "Claim", "procedure", element.getProcedure(), -1); 2801 } 2802 2803 protected void composeClaimInsuranceComponent(Complex parent, String parentType, String name, Claim.InsuranceComponent element, int index) { 2804 if (element == null) 2805 return; 2806 Complex t; 2807 if (Utilities.noString(parentType)) 2808 t = parent; 2809 else { 2810 t = parent.predicate("fhir:"+parentType+'.'+name); 2811 } 2812 composeBackboneElement(t, "insurance", name, element, index); 2813 if (element.hasSequenceElement()) 2814 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2815 if (element.hasFocalElement()) 2816 composeBoolean(t, "Claim", "focal", element.getFocalElement(), -1); 2817 if (element.hasCoverage()) 2818 composeReference(t, "Claim", "coverage", element.getCoverage(), -1); 2819 if (element.hasBusinessArrangementElement()) 2820 composeString(t, "Claim", "businessArrangement", element.getBusinessArrangementElement(), -1); 2821 for (int i = 0; i < element.getPreAuthRef().size(); i++) 2822 composeString(t, "Claim", "preAuthRef", element.getPreAuthRef().get(i), i); 2823 if (element.hasClaimResponse()) 2824 composeReference(t, "Claim", "claimResponse", element.getClaimResponse(), -1); 2825 } 2826 2827 protected void composeClaimAccidentComponent(Complex parent, String parentType, String name, Claim.AccidentComponent element, int index) { 2828 if (element == null) 2829 return; 2830 Complex t; 2831 if (Utilities.noString(parentType)) 2832 t = parent; 2833 else { 2834 t = parent.predicate("fhir:"+parentType+'.'+name); 2835 } 2836 composeBackboneElement(t, "accident", name, element, index); 2837 if (element.hasDateElement()) 2838 composeDate(t, "Claim", "date", element.getDateElement(), -1); 2839 if (element.hasType()) 2840 composeCodeableConcept(t, "Claim", "type", element.getType(), -1); 2841 if (element.hasLocation()) 2842 composeType(t, "Claim", "location", element.getLocation(), -1); 2843 } 2844 2845 protected void composeClaimItemComponent(Complex parent, String parentType, String name, Claim.ItemComponent element, int index) { 2846 if (element == null) 2847 return; 2848 Complex t; 2849 if (Utilities.noString(parentType)) 2850 t = parent; 2851 else { 2852 t = parent.predicate("fhir:"+parentType+'.'+name); 2853 } 2854 composeBackboneElement(t, "item", name, element, index); 2855 if (element.hasSequenceElement()) 2856 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2857 for (int i = 0; i < element.getCareTeamLinkId().size(); i++) 2858 composePositiveInt(t, "Claim", "careTeamLinkId", element.getCareTeamLinkId().get(i), i); 2859 for (int i = 0; i < element.getDiagnosisLinkId().size(); i++) 2860 composePositiveInt(t, "Claim", "diagnosisLinkId", element.getDiagnosisLinkId().get(i), i); 2861 for (int i = 0; i < element.getProcedureLinkId().size(); i++) 2862 composePositiveInt(t, "Claim", "procedureLinkId", element.getProcedureLinkId().get(i), i); 2863 for (int i = 0; i < element.getInformationLinkId().size(); i++) 2864 composePositiveInt(t, "Claim", "informationLinkId", element.getInformationLinkId().get(i), i); 2865 if (element.hasRevenue()) 2866 composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1); 2867 if (element.hasCategory()) 2868 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 2869 if (element.hasService()) 2870 composeCodeableConcept(t, "Claim", "service", element.getService(), -1); 2871 for (int i = 0; i < element.getModifier().size(); i++) 2872 composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i); 2873 for (int i = 0; i < element.getProgramCode().size(); i++) 2874 composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i); 2875 if (element.hasServiced()) 2876 composeType(t, "Claim", "serviced", element.getServiced(), -1); 2877 if (element.hasLocation()) 2878 composeType(t, "Claim", "location", element.getLocation(), -1); 2879 if (element.hasQuantity()) 2880 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 2881 if (element.hasUnitPrice()) 2882 composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 2883 if (element.hasFactorElement()) 2884 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 2885 if (element.hasNet()) 2886 composeMoney(t, "Claim", "net", element.getNet(), -1); 2887 for (int i = 0; i < element.getUdi().size(); i++) 2888 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 2889 if (element.hasBodySite()) 2890 composeCodeableConcept(t, "Claim", "bodySite", element.getBodySite(), -1); 2891 for (int i = 0; i < element.getSubSite().size(); i++) 2892 composeCodeableConcept(t, "Claim", "subSite", element.getSubSite().get(i), i); 2893 for (int i = 0; i < element.getEncounter().size(); i++) 2894 composeReference(t, "Claim", "encounter", element.getEncounter().get(i), i); 2895 for (int i = 0; i < element.getDetail().size(); i++) 2896 composeClaimDetailComponent(t, "Claim", "detail", element.getDetail().get(i), i); 2897 } 2898 2899 protected void composeClaimDetailComponent(Complex parent, String parentType, String name, Claim.DetailComponent element, int index) { 2900 if (element == null) 2901 return; 2902 Complex t; 2903 if (Utilities.noString(parentType)) 2904 t = parent; 2905 else { 2906 t = parent.predicate("fhir:"+parentType+'.'+name); 2907 } 2908 composeBackboneElement(t, "detail", name, element, index); 2909 if (element.hasSequenceElement()) 2910 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2911 if (element.hasRevenue()) 2912 composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1); 2913 if (element.hasCategory()) 2914 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 2915 if (element.hasService()) 2916 composeCodeableConcept(t, "Claim", "service", element.getService(), -1); 2917 for (int i = 0; i < element.getModifier().size(); i++) 2918 composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i); 2919 for (int i = 0; i < element.getProgramCode().size(); i++) 2920 composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i); 2921 if (element.hasQuantity()) 2922 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 2923 if (element.hasUnitPrice()) 2924 composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 2925 if (element.hasFactorElement()) 2926 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 2927 if (element.hasNet()) 2928 composeMoney(t, "Claim", "net", element.getNet(), -1); 2929 for (int i = 0; i < element.getUdi().size(); i++) 2930 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 2931 for (int i = 0; i < element.getSubDetail().size(); i++) 2932 composeClaimSubDetailComponent(t, "Claim", "subDetail", element.getSubDetail().get(i), i); 2933 } 2934 2935 protected void composeClaimSubDetailComponent(Complex parent, String parentType, String name, Claim.SubDetailComponent element, int index) { 2936 if (element == null) 2937 return; 2938 Complex t; 2939 if (Utilities.noString(parentType)) 2940 t = parent; 2941 else { 2942 t = parent.predicate("fhir:"+parentType+'.'+name); 2943 } 2944 composeBackboneElement(t, "subDetail", name, element, index); 2945 if (element.hasSequenceElement()) 2946 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2947 if (element.hasRevenue()) 2948 composeCodeableConcept(t, "Claim", "revenue", element.getRevenue(), -1); 2949 if (element.hasCategory()) 2950 composeCodeableConcept(t, "Claim", "category", element.getCategory(), -1); 2951 if (element.hasService()) 2952 composeCodeableConcept(t, "Claim", "service", element.getService(), -1); 2953 for (int i = 0; i < element.getModifier().size(); i++) 2954 composeCodeableConcept(t, "Claim", "modifier", element.getModifier().get(i), i); 2955 for (int i = 0; i < element.getProgramCode().size(); i++) 2956 composeCodeableConcept(t, "Claim", "programCode", element.getProgramCode().get(i), i); 2957 if (element.hasQuantity()) 2958 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 2959 if (element.hasUnitPrice()) 2960 composeMoney(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 2961 if (element.hasFactorElement()) 2962 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 2963 if (element.hasNet()) 2964 composeMoney(t, "Claim", "net", element.getNet(), -1); 2965 for (int i = 0; i < element.getUdi().size(); i++) 2966 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 2967 } 2968 2969 protected void composeClaimResponse(Complex parent, String parentType, String name, ClaimResponse element, int index) { 2970 if (element == null) 2971 return; 2972 Complex t; 2973 if (Utilities.noString(parentType)) 2974 t = parent; 2975 else { 2976 t = parent.predicate("fhir:"+parentType+'.'+name); 2977 } 2978 composeDomainResource(t, "ClaimResponse", name, element, index); 2979 for (int i = 0; i < element.getIdentifier().size(); i++) 2980 composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier().get(i), i); 2981 if (element.hasStatusElement()) 2982 composeEnum(t, "ClaimResponse", "status", element.getStatusElement(), -1); 2983 if (element.hasPatient()) 2984 composeReference(t, "ClaimResponse", "patient", element.getPatient(), -1); 2985 if (element.hasCreatedElement()) 2986 composeDateTime(t, "ClaimResponse", "created", element.getCreatedElement(), -1); 2987 if (element.hasInsurer()) 2988 composeReference(t, "ClaimResponse", "insurer", element.getInsurer(), -1); 2989 if (element.hasRequestProvider()) 2990 composeReference(t, "ClaimResponse", "requestProvider", element.getRequestProvider(), -1); 2991 if (element.hasRequestOrganization()) 2992 composeReference(t, "ClaimResponse", "requestOrganization", element.getRequestOrganization(), -1); 2993 if (element.hasRequest()) 2994 composeReference(t, "ClaimResponse", "request", element.getRequest(), -1); 2995 if (element.hasOutcome()) 2996 composeCodeableConcept(t, "ClaimResponse", "outcome", element.getOutcome(), -1); 2997 if (element.hasDispositionElement()) 2998 composeString(t, "ClaimResponse", "disposition", element.getDispositionElement(), -1); 2999 if (element.hasPayeeType()) 3000 composeCodeableConcept(t, "ClaimResponse", "payeeType", element.getPayeeType(), -1); 3001 for (int i = 0; i < element.getItem().size(); i++) 3002 composeClaimResponseItemComponent(t, "ClaimResponse", "item", element.getItem().get(i), i); 3003 for (int i = 0; i < element.getAddItem().size(); i++) 3004 composeClaimResponseAddedItemComponent(t, "ClaimResponse", "addItem", element.getAddItem().get(i), i); 3005 for (int i = 0; i < element.getError().size(); i++) 3006 composeClaimResponseErrorComponent(t, "ClaimResponse", "error", element.getError().get(i), i); 3007 if (element.hasTotalCost()) 3008 composeMoney(t, "ClaimResponse", "totalCost", element.getTotalCost(), -1); 3009 if (element.hasUnallocDeductable()) 3010 composeMoney(t, "ClaimResponse", "unallocDeductable", element.getUnallocDeductable(), -1); 3011 if (element.hasTotalBenefit()) 3012 composeMoney(t, "ClaimResponse", "totalBenefit", element.getTotalBenefit(), -1); 3013 if (element.hasPayment()) 3014 composeClaimResponsePaymentComponent(t, "ClaimResponse", "payment", element.getPayment(), -1); 3015 if (element.hasReserved()) 3016 composeCoding(t, "ClaimResponse", "reserved", element.getReserved(), -1); 3017 if (element.hasForm()) 3018 composeCodeableConcept(t, "ClaimResponse", "form", element.getForm(), -1); 3019 for (int i = 0; i < element.getProcessNote().size(); i++) 3020 composeClaimResponseNoteComponent(t, "ClaimResponse", "processNote", element.getProcessNote().get(i), i); 3021 for (int i = 0; i < element.getCommunicationRequest().size(); i++) 3022 composeReference(t, "ClaimResponse", "communicationRequest", element.getCommunicationRequest().get(i), i); 3023 for (int i = 0; i < element.getInsurance().size(); i++) 3024 composeClaimResponseInsuranceComponent(t, "ClaimResponse", "insurance", element.getInsurance().get(i), i); 3025 } 3026 3027 protected void composeClaimResponseItemComponent(Complex parent, String parentType, String name, ClaimResponse.ItemComponent element, int index) { 3028 if (element == null) 3029 return; 3030 Complex t; 3031 if (Utilities.noString(parentType)) 3032 t = parent; 3033 else { 3034 t = parent.predicate("fhir:"+parentType+'.'+name); 3035 } 3036 composeBackboneElement(t, "item", name, element, index); 3037 if (element.hasSequenceLinkIdElement()) 3038 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 3039 for (int i = 0; i < element.getNoteNumber().size(); i++) 3040 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3041 for (int i = 0; i < element.getAdjudication().size(); i++) 3042 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3043 for (int i = 0; i < element.getDetail().size(); i++) 3044 composeClaimResponseItemDetailComponent(t, "ClaimResponse", "detail", element.getDetail().get(i), i); 3045 } 3046 3047 protected void composeClaimResponseAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.AdjudicationComponent element, int index) { 3048 if (element == null) 3049 return; 3050 Complex t; 3051 if (Utilities.noString(parentType)) 3052 t = parent; 3053 else { 3054 t = parent.predicate("fhir:"+parentType+'.'+name); 3055 } 3056 composeBackboneElement(t, "adjudication", name, element, index); 3057 if (element.hasCategory()) 3058 composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1); 3059 if (element.hasReason()) 3060 composeCodeableConcept(t, "ClaimResponse", "reason", element.getReason(), -1); 3061 if (element.hasAmount()) 3062 composeMoney(t, "ClaimResponse", "amount", element.getAmount(), -1); 3063 if (element.hasValueElement()) 3064 composeDecimal(t, "ClaimResponse", "value", element.getValueElement(), -1); 3065 } 3066 3067 protected void composeClaimResponseItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.ItemDetailComponent element, int index) { 3068 if (element == null) 3069 return; 3070 Complex t; 3071 if (Utilities.noString(parentType)) 3072 t = parent; 3073 else { 3074 t = parent.predicate("fhir:"+parentType+'.'+name); 3075 } 3076 composeBackboneElement(t, "detail", name, element, index); 3077 if (element.hasSequenceLinkIdElement()) 3078 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 3079 for (int i = 0; i < element.getNoteNumber().size(); i++) 3080 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3081 for (int i = 0; i < element.getAdjudication().size(); i++) 3082 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3083 for (int i = 0; i < element.getSubDetail().size(); i++) 3084 composeClaimResponseSubDetailComponent(t, "ClaimResponse", "subDetail", element.getSubDetail().get(i), i); 3085 } 3086 3087 protected void composeClaimResponseSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.SubDetailComponent element, int index) { 3088 if (element == null) 3089 return; 3090 Complex t; 3091 if (Utilities.noString(parentType)) 3092 t = parent; 3093 else { 3094 t = parent.predicate("fhir:"+parentType+'.'+name); 3095 } 3096 composeBackboneElement(t, "subDetail", name, element, index); 3097 if (element.hasSequenceLinkIdElement()) 3098 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 3099 for (int i = 0; i < element.getNoteNumber().size(); i++) 3100 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3101 for (int i = 0; i < element.getAdjudication().size(); i++) 3102 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3103 } 3104 3105 protected void composeClaimResponseAddedItemComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemComponent element, int index) { 3106 if (element == null) 3107 return; 3108 Complex t; 3109 if (Utilities.noString(parentType)) 3110 t = parent; 3111 else { 3112 t = parent.predicate("fhir:"+parentType+'.'+name); 3113 } 3114 composeBackboneElement(t, "addItem", name, element, index); 3115 for (int i = 0; i < element.getSequenceLinkId().size(); i++) 3116 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkId().get(i), i); 3117 if (element.hasRevenue()) 3118 composeCodeableConcept(t, "ClaimResponse", "revenue", element.getRevenue(), -1); 3119 if (element.hasCategory()) 3120 composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1); 3121 if (element.hasService()) 3122 composeCodeableConcept(t, "ClaimResponse", "service", element.getService(), -1); 3123 for (int i = 0; i < element.getModifier().size(); i++) 3124 composeCodeableConcept(t, "ClaimResponse", "modifier", element.getModifier().get(i), i); 3125 if (element.hasFee()) 3126 composeMoney(t, "ClaimResponse", "fee", element.getFee(), -1); 3127 for (int i = 0; i < element.getNoteNumber().size(); i++) 3128 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3129 for (int i = 0; i < element.getAdjudication().size(); i++) 3130 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3131 for (int i = 0; i < element.getDetail().size(); i++) 3132 composeClaimResponseAddedItemsDetailComponent(t, "ClaimResponse", "detail", element.getDetail().get(i), i); 3133 } 3134 3135 protected void composeClaimResponseAddedItemsDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemsDetailComponent element, int index) { 3136 if (element == null) 3137 return; 3138 Complex t; 3139 if (Utilities.noString(parentType)) 3140 t = parent; 3141 else { 3142 t = parent.predicate("fhir:"+parentType+'.'+name); 3143 } 3144 composeBackboneElement(t, "detail", name, element, index); 3145 if (element.hasRevenue()) 3146 composeCodeableConcept(t, "ClaimResponse", "revenue", element.getRevenue(), -1); 3147 if (element.hasCategory()) 3148 composeCodeableConcept(t, "ClaimResponse", "category", element.getCategory(), -1); 3149 if (element.hasService()) 3150 composeCodeableConcept(t, "ClaimResponse", "service", element.getService(), -1); 3151 for (int i = 0; i < element.getModifier().size(); i++) 3152 composeCodeableConcept(t, "ClaimResponse", "modifier", element.getModifier().get(i), i); 3153 if (element.hasFee()) 3154 composeMoney(t, "ClaimResponse", "fee", element.getFee(), -1); 3155 for (int i = 0; i < element.getNoteNumber().size(); i++) 3156 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 3157 for (int i = 0; i < element.getAdjudication().size(); i++) 3158 composeClaimResponseAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 3159 } 3160 3161 protected void composeClaimResponseErrorComponent(Complex parent, String parentType, String name, ClaimResponse.ErrorComponent element, int index) { 3162 if (element == null) 3163 return; 3164 Complex t; 3165 if (Utilities.noString(parentType)) 3166 t = parent; 3167 else { 3168 t = parent.predicate("fhir:"+parentType+'.'+name); 3169 } 3170 composeBackboneElement(t, "error", name, element, index); 3171 if (element.hasSequenceLinkIdElement()) 3172 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 3173 if (element.hasDetailSequenceLinkIdElement()) 3174 composePositiveInt(t, "ClaimResponse", "detailSequenceLinkId", element.getDetailSequenceLinkIdElement(), -1); 3175 if (element.hasSubdetailSequenceLinkIdElement()) 3176 composePositiveInt(t, "ClaimResponse", "subdetailSequenceLinkId", element.getSubdetailSequenceLinkIdElement(), -1); 3177 if (element.hasCode()) 3178 composeCodeableConcept(t, "ClaimResponse", "code", element.getCode(), -1); 3179 } 3180 3181 protected void composeClaimResponsePaymentComponent(Complex parent, String parentType, String name, ClaimResponse.PaymentComponent element, int index) { 3182 if (element == null) 3183 return; 3184 Complex t; 3185 if (Utilities.noString(parentType)) 3186 t = parent; 3187 else { 3188 t = parent.predicate("fhir:"+parentType+'.'+name); 3189 } 3190 composeBackboneElement(t, "payment", name, element, index); 3191 if (element.hasType()) 3192 composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1); 3193 if (element.hasAdjustment()) 3194 composeMoney(t, "ClaimResponse", "adjustment", element.getAdjustment(), -1); 3195 if (element.hasAdjustmentReason()) 3196 composeCodeableConcept(t, "ClaimResponse", "adjustmentReason", element.getAdjustmentReason(), -1); 3197 if (element.hasDateElement()) 3198 composeDate(t, "ClaimResponse", "date", element.getDateElement(), -1); 3199 if (element.hasAmount()) 3200 composeMoney(t, "ClaimResponse", "amount", element.getAmount(), -1); 3201 if (element.hasIdentifier()) 3202 composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier(), -1); 3203 } 3204 3205 protected void composeClaimResponseNoteComponent(Complex parent, String parentType, String name, ClaimResponse.NoteComponent element, int index) { 3206 if (element == null) 3207 return; 3208 Complex t; 3209 if (Utilities.noString(parentType)) 3210 t = parent; 3211 else { 3212 t = parent.predicate("fhir:"+parentType+'.'+name); 3213 } 3214 composeBackboneElement(t, "processNote", name, element, index); 3215 if (element.hasNumberElement()) 3216 composePositiveInt(t, "ClaimResponse", "number", element.getNumberElement(), -1); 3217 if (element.hasType()) 3218 composeCodeableConcept(t, "ClaimResponse", "type", element.getType(), -1); 3219 if (element.hasTextElement()) 3220 composeString(t, "ClaimResponse", "text", element.getTextElement(), -1); 3221 if (element.hasLanguage()) 3222 composeCodeableConcept(t, "ClaimResponse", "language", element.getLanguage(), -1); 3223 } 3224 3225 protected void composeClaimResponseInsuranceComponent(Complex parent, String parentType, String name, ClaimResponse.InsuranceComponent element, int index) { 3226 if (element == null) 3227 return; 3228 Complex t; 3229 if (Utilities.noString(parentType)) 3230 t = parent; 3231 else { 3232 t = parent.predicate("fhir:"+parentType+'.'+name); 3233 } 3234 composeBackboneElement(t, "insurance", name, element, index); 3235 if (element.hasSequenceElement()) 3236 composePositiveInt(t, "ClaimResponse", "sequence", element.getSequenceElement(), -1); 3237 if (element.hasFocalElement()) 3238 composeBoolean(t, "ClaimResponse", "focal", element.getFocalElement(), -1); 3239 if (element.hasCoverage()) 3240 composeReference(t, "ClaimResponse", "coverage", element.getCoverage(), -1); 3241 if (element.hasBusinessArrangementElement()) 3242 composeString(t, "ClaimResponse", "businessArrangement", element.getBusinessArrangementElement(), -1); 3243 for (int i = 0; i < element.getPreAuthRef().size(); i++) 3244 composeString(t, "ClaimResponse", "preAuthRef", element.getPreAuthRef().get(i), i); 3245 if (element.hasClaimResponse()) 3246 composeReference(t, "ClaimResponse", "claimResponse", element.getClaimResponse(), -1); 3247 } 3248 3249 protected void composeClinicalImpression(Complex parent, String parentType, String name, ClinicalImpression element, int index) { 3250 if (element == null) 3251 return; 3252 Complex t; 3253 if (Utilities.noString(parentType)) 3254 t = parent; 3255 else { 3256 t = parent.predicate("fhir:"+parentType+'.'+name); 3257 } 3258 composeDomainResource(t, "ClinicalImpression", name, element, index); 3259 for (int i = 0; i < element.getIdentifier().size(); i++) 3260 composeIdentifier(t, "ClinicalImpression", "identifier", element.getIdentifier().get(i), i); 3261 if (element.hasStatusElement()) 3262 composeEnum(t, "ClinicalImpression", "status", element.getStatusElement(), -1); 3263 if (element.hasCode()) 3264 composeCodeableConcept(t, "ClinicalImpression", "code", element.getCode(), -1); 3265 if (element.hasDescriptionElement()) 3266 composeString(t, "ClinicalImpression", "description", element.getDescriptionElement(), -1); 3267 if (element.hasSubject()) 3268 composeReference(t, "ClinicalImpression", "subject", element.getSubject(), -1); 3269 if (element.hasContext()) 3270 composeReference(t, "ClinicalImpression", "context", element.getContext(), -1); 3271 if (element.hasEffective()) 3272 composeType(t, "ClinicalImpression", "effective", element.getEffective(), -1); 3273 if (element.hasDateElement()) 3274 composeDateTime(t, "ClinicalImpression", "date", element.getDateElement(), -1); 3275 if (element.hasAssessor()) 3276 composeReference(t, "ClinicalImpression", "assessor", element.getAssessor(), -1); 3277 if (element.hasPrevious()) 3278 composeReference(t, "ClinicalImpression", "previous", element.getPrevious(), -1); 3279 for (int i = 0; i < element.getProblem().size(); i++) 3280 composeReference(t, "ClinicalImpression", "problem", element.getProblem().get(i), i); 3281 for (int i = 0; i < element.getInvestigation().size(); i++) 3282 composeClinicalImpressionClinicalImpressionInvestigationComponent(t, "ClinicalImpression", "investigation", element.getInvestigation().get(i), i); 3283 for (int i = 0; i < element.getProtocol().size(); i++) 3284 composeUri(t, "ClinicalImpression", "protocol", element.getProtocol().get(i), i); 3285 if (element.hasSummaryElement()) 3286 composeString(t, "ClinicalImpression", "summary", element.getSummaryElement(), -1); 3287 for (int i = 0; i < element.getFinding().size(); i++) 3288 composeClinicalImpressionClinicalImpressionFindingComponent(t, "ClinicalImpression", "finding", element.getFinding().get(i), i); 3289 for (int i = 0; i < element.getPrognosisCodeableConcept().size(); i++) 3290 composeCodeableConcept(t, "ClinicalImpression", "prognosisCodeableConcept", element.getPrognosisCodeableConcept().get(i), i); 3291 for (int i = 0; i < element.getPrognosisReference().size(); i++) 3292 composeReference(t, "ClinicalImpression", "prognosisReference", element.getPrognosisReference().get(i), i); 3293 for (int i = 0; i < element.getAction().size(); i++) 3294 composeReference(t, "ClinicalImpression", "action", element.getAction().get(i), i); 3295 for (int i = 0; i < element.getNote().size(); i++) 3296 composeAnnotation(t, "ClinicalImpression", "note", element.getNote().get(i), i); 3297 } 3298 3299 protected void composeClinicalImpressionClinicalImpressionInvestigationComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionInvestigationComponent element, int index) { 3300 if (element == null) 3301 return; 3302 Complex t; 3303 if (Utilities.noString(parentType)) 3304 t = parent; 3305 else { 3306 t = parent.predicate("fhir:"+parentType+'.'+name); 3307 } 3308 composeBackboneElement(t, "investigation", name, element, index); 3309 if (element.hasCode()) 3310 composeCodeableConcept(t, "ClinicalImpression", "code", element.getCode(), -1); 3311 for (int i = 0; i < element.getItem().size(); i++) 3312 composeReference(t, "ClinicalImpression", "item", element.getItem().get(i), i); 3313 } 3314 3315 protected void composeClinicalImpressionClinicalImpressionFindingComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionFindingComponent element, int index) { 3316 if (element == null) 3317 return; 3318 Complex t; 3319 if (Utilities.noString(parentType)) 3320 t = parent; 3321 else { 3322 t = parent.predicate("fhir:"+parentType+'.'+name); 3323 } 3324 composeBackboneElement(t, "finding", name, element, index); 3325 if (element.hasItem()) 3326 composeType(t, "ClinicalImpression", "item", element.getItem(), -1); 3327 if (element.hasBasisElement()) 3328 composeString(t, "ClinicalImpression", "basis", element.getBasisElement(), -1); 3329 } 3330 3331 protected void composeCodeSystem(Complex parent, String parentType, String name, CodeSystem element, int index) { 3332 if (element == null) 3333 return; 3334 Complex t; 3335 if (Utilities.noString(parentType)) 3336 t = parent; 3337 else { 3338 t = parent.predicate("fhir:"+parentType+'.'+name); 3339 } 3340 composeDomainResource(t, "CodeSystem", name, element, index); 3341 if (element.hasUrlElement()) 3342 composeUri(t, "CodeSystem", "url", element.getUrlElement(), -1); 3343 if (element.hasIdentifier()) 3344 composeIdentifier(t, "CodeSystem", "identifier", element.getIdentifier(), -1); 3345 if (element.hasVersionElement()) 3346 composeString(t, "CodeSystem", "version", element.getVersionElement(), -1); 3347 if (element.hasNameElement()) 3348 composeString(t, "CodeSystem", "name", element.getNameElement(), -1); 3349 if (element.hasTitleElement()) 3350 composeString(t, "CodeSystem", "title", element.getTitleElement(), -1); 3351 if (element.hasStatusElement()) 3352 composeEnum(t, "CodeSystem", "status", element.getStatusElement(), -1); 3353 if (element.hasExperimentalElement()) 3354 composeBoolean(t, "CodeSystem", "experimental", element.getExperimentalElement(), -1); 3355 if (element.hasDateElement()) 3356 composeDateTime(t, "CodeSystem", "date", element.getDateElement(), -1); 3357 if (element.hasPublisherElement()) 3358 composeString(t, "CodeSystem", "publisher", element.getPublisherElement(), -1); 3359 for (int i = 0; i < element.getContact().size(); i++) 3360 composeContactDetail(t, "CodeSystem", "contact", element.getContact().get(i), i); 3361 if (element.hasDescriptionElement()) 3362 composeMarkdown(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 3363 for (int i = 0; i < element.getUseContext().size(); i++) 3364 composeUsageContext(t, "CodeSystem", "useContext", element.getUseContext().get(i), i); 3365 for (int i = 0; i < element.getJurisdiction().size(); i++) 3366 composeCodeableConcept(t, "CodeSystem", "jurisdiction", element.getJurisdiction().get(i), i); 3367 if (element.hasPurposeElement()) 3368 composeMarkdown(t, "CodeSystem", "purpose", element.getPurposeElement(), -1); 3369 if (element.hasCopyrightElement()) 3370 composeMarkdown(t, "CodeSystem", "copyright", element.getCopyrightElement(), -1); 3371 if (element.hasCaseSensitiveElement()) 3372 composeBoolean(t, "CodeSystem", "caseSensitive", element.getCaseSensitiveElement(), -1); 3373 if (element.hasValueSetElement()) 3374 composeUri(t, "CodeSystem", "valueSet", element.getValueSetElement(), -1); 3375 if (element.hasHierarchyMeaningElement()) 3376 composeEnum(t, "CodeSystem", "hierarchyMeaning", element.getHierarchyMeaningElement(), -1); 3377 if (element.hasCompositionalElement()) 3378 composeBoolean(t, "CodeSystem", "compositional", element.getCompositionalElement(), -1); 3379 if (element.hasVersionNeededElement()) 3380 composeBoolean(t, "CodeSystem", "versionNeeded", element.getVersionNeededElement(), -1); 3381 if (element.hasContentElement()) 3382 composeEnum(t, "CodeSystem", "content", element.getContentElement(), -1); 3383 if (element.hasCountElement()) 3384 composeUnsignedInt(t, "CodeSystem", "count", element.getCountElement(), -1); 3385 for (int i = 0; i < element.getFilter().size(); i++) 3386 composeCodeSystemCodeSystemFilterComponent(t, "CodeSystem", "filter", element.getFilter().get(i), i); 3387 for (int i = 0; i < element.getProperty().size(); i++) 3388 composeCodeSystemPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i); 3389 for (int i = 0; i < element.getConcept().size(); i++) 3390 composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i); 3391 } 3392 3393 protected void composeCodeSystemCodeSystemFilterComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemFilterComponent element, int index) { 3394 if (element == null) 3395 return; 3396 Complex t; 3397 if (Utilities.noString(parentType)) 3398 t = parent; 3399 else { 3400 t = parent.predicate("fhir:"+parentType+'.'+name); 3401 } 3402 composeBackboneElement(t, "filter", name, element, index); 3403 if (element.hasCodeElement()) 3404 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 3405 if (element.hasDescriptionElement()) 3406 composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 3407 for (int i = 0; i < element.getOperator().size(); i++) 3408 composeEnum(t, "CodeSystem", "operator", element.getOperator().get(i), i); 3409 if (element.hasValueElement()) 3410 composeString(t, "CodeSystem", "value", element.getValueElement(), -1); 3411 } 3412 3413 protected void composeCodeSystemPropertyComponent(Complex parent, String parentType, String name, CodeSystem.PropertyComponent element, int index) { 3414 if (element == null) 3415 return; 3416 Complex t; 3417 if (Utilities.noString(parentType)) 3418 t = parent; 3419 else { 3420 t = parent.predicate("fhir:"+parentType+'.'+name); 3421 } 3422 composeBackboneElement(t, "property", name, element, index); 3423 if (element.hasCodeElement()) 3424 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 3425 if (element.hasUriElement()) 3426 composeUri(t, "CodeSystem", "uri", element.getUriElement(), -1); 3427 if (element.hasDescriptionElement()) 3428 composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 3429 if (element.hasTypeElement()) 3430 composeEnum(t, "CodeSystem", "type", element.getTypeElement(), -1); 3431 } 3432 3433 protected void composeCodeSystemConceptDefinitionComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionComponent element, int index) { 3434 if (element == null) 3435 return; 3436 Complex t; 3437 if (Utilities.noString(parentType)) 3438 t = parent; 3439 else { 3440 t = parent.predicate("fhir:"+parentType+'.'+name); 3441 } 3442 composeBackboneElement(t, "concept", name, element, index); 3443 if (element.hasCodeElement()) 3444 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 3445 if (element.hasDisplayElement()) 3446 composeString(t, "CodeSystem", "display", element.getDisplayElement(), -1); 3447 if (element.hasDefinitionElement()) 3448 composeString(t, "CodeSystem", "definition", element.getDefinitionElement(), -1); 3449 for (int i = 0; i < element.getDesignation().size(); i++) 3450 composeCodeSystemConceptDefinitionDesignationComponent(t, "CodeSystem", "designation", element.getDesignation().get(i), i); 3451 for (int i = 0; i < element.getProperty().size(); i++) 3452 composeCodeSystemConceptPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i); 3453 for (int i = 0; i < element.getConcept().size(); i++) 3454 composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i); 3455 } 3456 3457 protected void composeCodeSystemConceptDefinitionDesignationComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionDesignationComponent element, int index) { 3458 if (element == null) 3459 return; 3460 Complex t; 3461 if (Utilities.noString(parentType)) 3462 t = parent; 3463 else { 3464 t = parent.predicate("fhir:"+parentType+'.'+name); 3465 } 3466 composeBackboneElement(t, "designation", name, element, index); 3467 if (element.hasLanguageElement()) 3468 composeCode(t, "CodeSystem", "language", element.getLanguageElement(), -1); 3469 if (element.hasUse()) 3470 composeCoding(t, "CodeSystem", "use", element.getUse(), -1); 3471 if (element.hasValueElement()) 3472 composeString(t, "CodeSystem", "value", element.getValueElement(), -1); 3473 } 3474 3475 protected void composeCodeSystemConceptPropertyComponent(Complex parent, String parentType, String name, CodeSystem.ConceptPropertyComponent element, int index) { 3476 if (element == null) 3477 return; 3478 Complex t; 3479 if (Utilities.noString(parentType)) 3480 t = parent; 3481 else { 3482 t = parent.predicate("fhir:"+parentType+'.'+name); 3483 } 3484 composeBackboneElement(t, "property", name, element, index); 3485 if (element.hasCodeElement()) 3486 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 3487 if (element.hasValue()) 3488 composeType(t, "CodeSystem", "value", element.getValue(), -1); 3489 } 3490 3491 protected void composeCommunication(Complex parent, String parentType, String name, Communication element, int index) { 3492 if (element == null) 3493 return; 3494 Complex t; 3495 if (Utilities.noString(parentType)) 3496 t = parent; 3497 else { 3498 t = parent.predicate("fhir:"+parentType+'.'+name); 3499 } 3500 composeDomainResource(t, "Communication", name, element, index); 3501 for (int i = 0; i < element.getIdentifier().size(); i++) 3502 composeIdentifier(t, "Communication", "identifier", element.getIdentifier().get(i), i); 3503 for (int i = 0; i < element.getDefinition().size(); i++) 3504 composeReference(t, "Communication", "definition", element.getDefinition().get(i), i); 3505 for (int i = 0; i < element.getBasedOn().size(); i++) 3506 composeReference(t, "Communication", "basedOn", element.getBasedOn().get(i), i); 3507 for (int i = 0; i < element.getPartOf().size(); i++) 3508 composeReference(t, "Communication", "partOf", element.getPartOf().get(i), i); 3509 if (element.hasStatusElement()) 3510 composeEnum(t, "Communication", "status", element.getStatusElement(), -1); 3511 if (element.hasNotDoneElement()) 3512 composeBoolean(t, "Communication", "notDone", element.getNotDoneElement(), -1); 3513 if (element.hasNotDoneReason()) 3514 composeCodeableConcept(t, "Communication", "notDoneReason", element.getNotDoneReason(), -1); 3515 for (int i = 0; i < element.getCategory().size(); i++) 3516 composeCodeableConcept(t, "Communication", "category", element.getCategory().get(i), i); 3517 for (int i = 0; i < element.getMedium().size(); i++) 3518 composeCodeableConcept(t, "Communication", "medium", element.getMedium().get(i), i); 3519 if (element.hasSubject()) 3520 composeReference(t, "Communication", "subject", element.getSubject(), -1); 3521 for (int i = 0; i < element.getRecipient().size(); i++) 3522 composeReference(t, "Communication", "recipient", element.getRecipient().get(i), i); 3523 for (int i = 0; i < element.getTopic().size(); i++) 3524 composeReference(t, "Communication", "topic", element.getTopic().get(i), i); 3525 if (element.hasContext()) 3526 composeReference(t, "Communication", "context", element.getContext(), -1); 3527 if (element.hasSentElement()) 3528 composeDateTime(t, "Communication", "sent", element.getSentElement(), -1); 3529 if (element.hasReceivedElement()) 3530 composeDateTime(t, "Communication", "received", element.getReceivedElement(), -1); 3531 if (element.hasSender()) 3532 composeReference(t, "Communication", "sender", element.getSender(), -1); 3533 for (int i = 0; i < element.getReasonCode().size(); i++) 3534 composeCodeableConcept(t, "Communication", "reasonCode", element.getReasonCode().get(i), i); 3535 for (int i = 0; i < element.getReasonReference().size(); i++) 3536 composeReference(t, "Communication", "reasonReference", element.getReasonReference().get(i), i); 3537 for (int i = 0; i < element.getPayload().size(); i++) 3538 composeCommunicationCommunicationPayloadComponent(t, "Communication", "payload", element.getPayload().get(i), i); 3539 for (int i = 0; i < element.getNote().size(); i++) 3540 composeAnnotation(t, "Communication", "note", element.getNote().get(i), i); 3541 } 3542 3543 protected void composeCommunicationCommunicationPayloadComponent(Complex parent, String parentType, String name, Communication.CommunicationPayloadComponent element, int index) { 3544 if (element == null) 3545 return; 3546 Complex t; 3547 if (Utilities.noString(parentType)) 3548 t = parent; 3549 else { 3550 t = parent.predicate("fhir:"+parentType+'.'+name); 3551 } 3552 composeBackboneElement(t, "payload", name, element, index); 3553 if (element.hasContent()) 3554 composeType(t, "Communication", "content", element.getContent(), -1); 3555 } 3556 3557 protected void composeCommunicationRequest(Complex parent, String parentType, String name, CommunicationRequest element, int index) { 3558 if (element == null) 3559 return; 3560 Complex t; 3561 if (Utilities.noString(parentType)) 3562 t = parent; 3563 else { 3564 t = parent.predicate("fhir:"+parentType+'.'+name); 3565 } 3566 composeDomainResource(t, "CommunicationRequest", name, element, index); 3567 for (int i = 0; i < element.getIdentifier().size(); i++) 3568 composeIdentifier(t, "CommunicationRequest", "identifier", element.getIdentifier().get(i), i); 3569 for (int i = 0; i < element.getBasedOn().size(); i++) 3570 composeReference(t, "CommunicationRequest", "basedOn", element.getBasedOn().get(i), i); 3571 for (int i = 0; i < element.getReplaces().size(); i++) 3572 composeReference(t, "CommunicationRequest", "replaces", element.getReplaces().get(i), i); 3573 if (element.hasGroupIdentifier()) 3574 composeIdentifier(t, "CommunicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 3575 if (element.hasStatusElement()) 3576 composeEnum(t, "CommunicationRequest", "status", element.getStatusElement(), -1); 3577 for (int i = 0; i < element.getCategory().size(); i++) 3578 composeCodeableConcept(t, "CommunicationRequest", "category", element.getCategory().get(i), i); 3579 if (element.hasPriorityElement()) 3580 composeEnum(t, "CommunicationRequest", "priority", element.getPriorityElement(), -1); 3581 for (int i = 0; i < element.getMedium().size(); i++) 3582 composeCodeableConcept(t, "CommunicationRequest", "medium", element.getMedium().get(i), i); 3583 if (element.hasSubject()) 3584 composeReference(t, "CommunicationRequest", "subject", element.getSubject(), -1); 3585 for (int i = 0; i < element.getRecipient().size(); i++) 3586 composeReference(t, "CommunicationRequest", "recipient", element.getRecipient().get(i), i); 3587 for (int i = 0; i < element.getTopic().size(); i++) 3588 composeReference(t, "CommunicationRequest", "topic", element.getTopic().get(i), i); 3589 if (element.hasContext()) 3590 composeReference(t, "CommunicationRequest", "context", element.getContext(), -1); 3591 for (int i = 0; i < element.getPayload().size(); i++) 3592 composeCommunicationRequestCommunicationRequestPayloadComponent(t, "CommunicationRequest", "payload", element.getPayload().get(i), i); 3593 if (element.hasOccurrence()) 3594 composeType(t, "CommunicationRequest", "occurrence", element.getOccurrence(), -1); 3595 if (element.hasAuthoredOnElement()) 3596 composeDateTime(t, "CommunicationRequest", "authoredOn", element.getAuthoredOnElement(), -1); 3597 if (element.hasSender()) 3598 composeReference(t, "CommunicationRequest", "sender", element.getSender(), -1); 3599 if (element.hasRequester()) 3600 composeCommunicationRequestCommunicationRequestRequesterComponent(t, "CommunicationRequest", "requester", element.getRequester(), -1); 3601 for (int i = 0; i < element.getReasonCode().size(); i++) 3602 composeCodeableConcept(t, "CommunicationRequest", "reasonCode", element.getReasonCode().get(i), i); 3603 for (int i = 0; i < element.getReasonReference().size(); i++) 3604 composeReference(t, "CommunicationRequest", "reasonReference", element.getReasonReference().get(i), i); 3605 for (int i = 0; i < element.getNote().size(); i++) 3606 composeAnnotation(t, "CommunicationRequest", "note", element.getNote().get(i), i); 3607 } 3608 3609 protected void composeCommunicationRequestCommunicationRequestPayloadComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestPayloadComponent element, int index) { 3610 if (element == null) 3611 return; 3612 Complex t; 3613 if (Utilities.noString(parentType)) 3614 t = parent; 3615 else { 3616 t = parent.predicate("fhir:"+parentType+'.'+name); 3617 } 3618 composeBackboneElement(t, "payload", name, element, index); 3619 if (element.hasContent()) 3620 composeType(t, "CommunicationRequest", "content", element.getContent(), -1); 3621 } 3622 3623 protected void composeCommunicationRequestCommunicationRequestRequesterComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestRequesterComponent element, int index) { 3624 if (element == null) 3625 return; 3626 Complex t; 3627 if (Utilities.noString(parentType)) 3628 t = parent; 3629 else { 3630 t = parent.predicate("fhir:"+parentType+'.'+name); 3631 } 3632 composeBackboneElement(t, "requester", name, element, index); 3633 if (element.hasAgent()) 3634 composeReference(t, "CommunicationRequest", "agent", element.getAgent(), -1); 3635 if (element.hasOnBehalfOf()) 3636 composeReference(t, "CommunicationRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 3637 } 3638 3639 protected void composeCompartmentDefinition(Complex parent, String parentType, String name, CompartmentDefinition element, int index) { 3640 if (element == null) 3641 return; 3642 Complex t; 3643 if (Utilities.noString(parentType)) 3644 t = parent; 3645 else { 3646 t = parent.predicate("fhir:"+parentType+'.'+name); 3647 } 3648 composeDomainResource(t, "CompartmentDefinition", name, element, index); 3649 if (element.hasUrlElement()) 3650 composeUri(t, "CompartmentDefinition", "url", element.getUrlElement(), -1); 3651 if (element.hasNameElement()) 3652 composeString(t, "CompartmentDefinition", "name", element.getNameElement(), -1); 3653 if (element.hasTitleElement()) 3654 composeString(t, "CompartmentDefinition", "title", element.getTitleElement(), -1); 3655 if (element.hasStatusElement()) 3656 composeEnum(t, "CompartmentDefinition", "status", element.getStatusElement(), -1); 3657 if (element.hasExperimentalElement()) 3658 composeBoolean(t, "CompartmentDefinition", "experimental", element.getExperimentalElement(), -1); 3659 if (element.hasDateElement()) 3660 composeDateTime(t, "CompartmentDefinition", "date", element.getDateElement(), -1); 3661 if (element.hasPublisherElement()) 3662 composeString(t, "CompartmentDefinition", "publisher", element.getPublisherElement(), -1); 3663 for (int i = 0; i < element.getContact().size(); i++) 3664 composeContactDetail(t, "CompartmentDefinition", "contact", element.getContact().get(i), i); 3665 if (element.hasDescriptionElement()) 3666 composeMarkdown(t, "CompartmentDefinition", "description", element.getDescriptionElement(), -1); 3667 if (element.hasPurposeElement()) 3668 composeMarkdown(t, "CompartmentDefinition", "purpose", element.getPurposeElement(), -1); 3669 for (int i = 0; i < element.getUseContext().size(); i++) 3670 composeUsageContext(t, "CompartmentDefinition", "useContext", element.getUseContext().get(i), i); 3671 for (int i = 0; i < element.getJurisdiction().size(); i++) 3672 composeCodeableConcept(t, "CompartmentDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 3673 if (element.hasCodeElement()) 3674 composeEnum(t, "CompartmentDefinition", "code", element.getCodeElement(), -1); 3675 if (element.hasSearchElement()) 3676 composeBoolean(t, "CompartmentDefinition", "search", element.getSearchElement(), -1); 3677 for (int i = 0; i < element.getResource().size(); i++) 3678 composeCompartmentDefinitionCompartmentDefinitionResourceComponent(t, "CompartmentDefinition", "resource", element.getResource().get(i), i); 3679 } 3680 3681 protected void composeCompartmentDefinitionCompartmentDefinitionResourceComponent(Complex parent, String parentType, String name, CompartmentDefinition.CompartmentDefinitionResourceComponent element, int index) { 3682 if (element == null) 3683 return; 3684 Complex t; 3685 if (Utilities.noString(parentType)) 3686 t = parent; 3687 else { 3688 t = parent.predicate("fhir:"+parentType+'.'+name); 3689 } 3690 composeBackboneElement(t, "resource", name, element, index); 3691 if (element.hasCodeElement()) 3692 composeCode(t, "CompartmentDefinition", "code", element.getCodeElement(), -1); 3693 for (int i = 0; i < element.getParam().size(); i++) 3694 composeString(t, "CompartmentDefinition", "param", element.getParam().get(i), i); 3695 if (element.hasDocumentationElement()) 3696 composeString(t, "CompartmentDefinition", "documentation", element.getDocumentationElement(), -1); 3697 } 3698 3699 protected void composeComposition(Complex parent, String parentType, String name, Composition element, int index) { 3700 if (element == null) 3701 return; 3702 Complex t; 3703 if (Utilities.noString(parentType)) 3704 t = parent; 3705 else { 3706 t = parent.predicate("fhir:"+parentType+'.'+name); 3707 } 3708 composeDomainResource(t, "Composition", name, element, index); 3709 if (element.hasIdentifier()) 3710 composeIdentifier(t, "Composition", "identifier", element.getIdentifier(), -1); 3711 if (element.hasStatusElement()) 3712 composeEnum(t, "Composition", "status", element.getStatusElement(), -1); 3713 if (element.hasType()) 3714 composeCodeableConcept(t, "Composition", "type", element.getType(), -1); 3715 if (element.hasClass_()) 3716 composeCodeableConcept(t, "Composition", "class", element.getClass_(), -1); 3717 if (element.hasSubject()) 3718 composeReference(t, "Composition", "subject", element.getSubject(), -1); 3719 if (element.hasEncounter()) 3720 composeReference(t, "Composition", "encounter", element.getEncounter(), -1); 3721 if (element.hasDateElement()) 3722 composeDateTime(t, "Composition", "date", element.getDateElement(), -1); 3723 for (int i = 0; i < element.getAuthor().size(); i++) 3724 composeReference(t, "Composition", "author", element.getAuthor().get(i), i); 3725 if (element.hasTitleElement()) 3726 composeString(t, "Composition", "title", element.getTitleElement(), -1); 3727 if (element.hasConfidentialityElement()) 3728 composeEnum(t, "Composition", "confidentiality", element.getConfidentialityElement(), -1); 3729 for (int i = 0; i < element.getAttester().size(); i++) 3730 composeCompositionCompositionAttesterComponent(t, "Composition", "attester", element.getAttester().get(i), i); 3731 if (element.hasCustodian()) 3732 composeReference(t, "Composition", "custodian", element.getCustodian(), -1); 3733 for (int i = 0; i < element.getRelatesTo().size(); i++) 3734 composeCompositionCompositionRelatesToComponent(t, "Composition", "relatesTo", element.getRelatesTo().get(i), i); 3735 for (int i = 0; i < element.getEvent().size(); i++) 3736 composeCompositionCompositionEventComponent(t, "Composition", "event", element.getEvent().get(i), i); 3737 for (int i = 0; i < element.getSection().size(); i++) 3738 composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i); 3739 } 3740 3741 protected void composeCompositionCompositionAttesterComponent(Complex parent, String parentType, String name, Composition.CompositionAttesterComponent element, int index) { 3742 if (element == null) 3743 return; 3744 Complex t; 3745 if (Utilities.noString(parentType)) 3746 t = parent; 3747 else { 3748 t = parent.predicate("fhir:"+parentType+'.'+name); 3749 } 3750 composeBackboneElement(t, "attester", name, element, index); 3751 for (int i = 0; i < element.getMode().size(); i++) 3752 composeEnum(t, "Composition", "mode", element.getMode().get(i), i); 3753 if (element.hasTimeElement()) 3754 composeDateTime(t, "Composition", "time", element.getTimeElement(), -1); 3755 if (element.hasParty()) 3756 composeReference(t, "Composition", "party", element.getParty(), -1); 3757 } 3758 3759 protected void composeCompositionCompositionRelatesToComponent(Complex parent, String parentType, String name, Composition.CompositionRelatesToComponent element, int index) { 3760 if (element == null) 3761 return; 3762 Complex t; 3763 if (Utilities.noString(parentType)) 3764 t = parent; 3765 else { 3766 t = parent.predicate("fhir:"+parentType+'.'+name); 3767 } 3768 composeBackboneElement(t, "relatesTo", name, element, index); 3769 if (element.hasCodeElement()) 3770 composeEnum(t, "Composition", "code", element.getCodeElement(), -1); 3771 if (element.hasTarget()) 3772 composeType(t, "Composition", "target", element.getTarget(), -1); 3773 } 3774 3775 protected void composeCompositionCompositionEventComponent(Complex parent, String parentType, String name, Composition.CompositionEventComponent element, int index) { 3776 if (element == null) 3777 return; 3778 Complex t; 3779 if (Utilities.noString(parentType)) 3780 t = parent; 3781 else { 3782 t = parent.predicate("fhir:"+parentType+'.'+name); 3783 } 3784 composeBackboneElement(t, "event", name, element, index); 3785 for (int i = 0; i < element.getCode().size(); i++) 3786 composeCodeableConcept(t, "Composition", "code", element.getCode().get(i), i); 3787 if (element.hasPeriod()) 3788 composePeriod(t, "Composition", "period", element.getPeriod(), -1); 3789 for (int i = 0; i < element.getDetail().size(); i++) 3790 composeReference(t, "Composition", "detail", element.getDetail().get(i), i); 3791 } 3792 3793 protected void composeCompositionSectionComponent(Complex parent, String parentType, String name, Composition.SectionComponent element, int index) { 3794 if (element == null) 3795 return; 3796 Complex t; 3797 if (Utilities.noString(parentType)) 3798 t = parent; 3799 else { 3800 t = parent.predicate("fhir:"+parentType+'.'+name); 3801 } 3802 composeBackboneElement(t, "section", name, element, index); 3803 if (element.hasTitleElement()) 3804 composeString(t, "Composition", "title", element.getTitleElement(), -1); 3805 if (element.hasCode()) 3806 composeCodeableConcept(t, "Composition", "code", element.getCode(), -1); 3807 if (element.hasText()) 3808 composeNarrative(t, "Composition", "text", element.getText(), -1); 3809 if (element.hasModeElement()) 3810 composeEnum(t, "Composition", "mode", element.getModeElement(), -1); 3811 if (element.hasOrderedBy()) 3812 composeCodeableConcept(t, "Composition", "orderedBy", element.getOrderedBy(), -1); 3813 for (int i = 0; i < element.getEntry().size(); i++) 3814 composeReference(t, "Composition", "entry", element.getEntry().get(i), i); 3815 if (element.hasEmptyReason()) 3816 composeCodeableConcept(t, "Composition", "emptyReason", element.getEmptyReason(), -1); 3817 for (int i = 0; i < element.getSection().size(); i++) 3818 composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i); 3819 } 3820 3821 protected void composeConceptMap(Complex parent, String parentType, String name, ConceptMap element, int index) { 3822 if (element == null) 3823 return; 3824 Complex t; 3825 if (Utilities.noString(parentType)) 3826 t = parent; 3827 else { 3828 t = parent.predicate("fhir:"+parentType+'.'+name); 3829 } 3830 composeDomainResource(t, "ConceptMap", name, element, index); 3831 if (element.hasUrlElement()) 3832 composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1); 3833 if (element.hasIdentifier()) 3834 composeIdentifier(t, "ConceptMap", "identifier", element.getIdentifier(), -1); 3835 if (element.hasVersionElement()) 3836 composeString(t, "ConceptMap", "version", element.getVersionElement(), -1); 3837 if (element.hasNameElement()) 3838 composeString(t, "ConceptMap", "name", element.getNameElement(), -1); 3839 if (element.hasTitleElement()) 3840 composeString(t, "ConceptMap", "title", element.getTitleElement(), -1); 3841 if (element.hasStatusElement()) 3842 composeEnum(t, "ConceptMap", "status", element.getStatusElement(), -1); 3843 if (element.hasExperimentalElement()) 3844 composeBoolean(t, "ConceptMap", "experimental", element.getExperimentalElement(), -1); 3845 if (element.hasDateElement()) 3846 composeDateTime(t, "ConceptMap", "date", element.getDateElement(), -1); 3847 if (element.hasPublisherElement()) 3848 composeString(t, "ConceptMap", "publisher", element.getPublisherElement(), -1); 3849 for (int i = 0; i < element.getContact().size(); i++) 3850 composeContactDetail(t, "ConceptMap", "contact", element.getContact().get(i), i); 3851 if (element.hasDescriptionElement()) 3852 composeMarkdown(t, "ConceptMap", "description", element.getDescriptionElement(), -1); 3853 for (int i = 0; i < element.getUseContext().size(); i++) 3854 composeUsageContext(t, "ConceptMap", "useContext", element.getUseContext().get(i), i); 3855 for (int i = 0; i < element.getJurisdiction().size(); i++) 3856 composeCodeableConcept(t, "ConceptMap", "jurisdiction", element.getJurisdiction().get(i), i); 3857 if (element.hasPurposeElement()) 3858 composeMarkdown(t, "ConceptMap", "purpose", element.getPurposeElement(), -1); 3859 if (element.hasCopyrightElement()) 3860 composeMarkdown(t, "ConceptMap", "copyright", element.getCopyrightElement(), -1); 3861 if (element.hasSource()) 3862 composeType(t, "ConceptMap", "source", element.getSource(), -1); 3863 if (element.hasTarget()) 3864 composeType(t, "ConceptMap", "target", element.getTarget(), -1); 3865 for (int i = 0; i < element.getGroup().size(); i++) 3866 composeConceptMapConceptMapGroupComponent(t, "ConceptMap", "group", element.getGroup().get(i), i); 3867 } 3868 3869 protected void composeConceptMapConceptMapGroupComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupComponent element, int index) { 3870 if (element == null) 3871 return; 3872 Complex t; 3873 if (Utilities.noString(parentType)) 3874 t = parent; 3875 else { 3876 t = parent.predicate("fhir:"+parentType+'.'+name); 3877 } 3878 composeBackboneElement(t, "group", name, element, index); 3879 if (element.hasSourceElement()) 3880 composeUri(t, "ConceptMap", "source", element.getSourceElement(), -1); 3881 if (element.hasSourceVersionElement()) 3882 composeString(t, "ConceptMap", "sourceVersion", element.getSourceVersionElement(), -1); 3883 if (element.hasTargetElement()) 3884 composeUri(t, "ConceptMap", "target", element.getTargetElement(), -1); 3885 if (element.hasTargetVersionElement()) 3886 composeString(t, "ConceptMap", "targetVersion", element.getTargetVersionElement(), -1); 3887 for (int i = 0; i < element.getElement().size(); i++) 3888 composeConceptMapSourceElementComponent(t, "ConceptMap", "element", element.getElement().get(i), i); 3889 if (element.hasUnmapped()) 3890 composeConceptMapConceptMapGroupUnmappedComponent(t, "ConceptMap", "unmapped", element.getUnmapped(), -1); 3891 } 3892 3893 protected void composeConceptMapSourceElementComponent(Complex parent, String parentType, String name, ConceptMap.SourceElementComponent element, int index) { 3894 if (element == null) 3895 return; 3896 Complex t; 3897 if (Utilities.noString(parentType)) 3898 t = parent; 3899 else { 3900 t = parent.predicate("fhir:"+parentType+'.'+name); 3901 } 3902 composeBackboneElement(t, "element", name, element, index); 3903 if (element.hasCodeElement()) 3904 composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1); 3905 if (element.hasDisplayElement()) 3906 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 3907 for (int i = 0; i < element.getTarget().size(); i++) 3908 composeConceptMapTargetElementComponent(t, "ConceptMap", "target", element.getTarget().get(i), i); 3909 } 3910 3911 protected void composeConceptMapTargetElementComponent(Complex parent, String parentType, String name, ConceptMap.TargetElementComponent element, int index) { 3912 if (element == null) 3913 return; 3914 Complex t; 3915 if (Utilities.noString(parentType)) 3916 t = parent; 3917 else { 3918 t = parent.predicate("fhir:"+parentType+'.'+name); 3919 } 3920 composeBackboneElement(t, "target", name, element, index); 3921 if (element.hasCodeElement()) 3922 composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1); 3923 if (element.hasDisplayElement()) 3924 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 3925 if (element.hasEquivalenceElement()) 3926 composeEnum(t, "ConceptMap", "equivalence", element.getEquivalenceElement(), -1); 3927 if (element.hasCommentElement()) 3928 composeString(t, "ConceptMap", "comment", element.getCommentElement(), -1); 3929 for (int i = 0; i < element.getDependsOn().size(); i++) 3930 composeConceptMapOtherElementComponent(t, "ConceptMap", "dependsOn", element.getDependsOn().get(i), i); 3931 for (int i = 0; i < element.getProduct().size(); i++) 3932 composeConceptMapOtherElementComponent(t, "ConceptMap", "product", element.getProduct().get(i), i); 3933 } 3934 3935 protected void composeConceptMapOtherElementComponent(Complex parent, String parentType, String name, ConceptMap.OtherElementComponent element, int index) { 3936 if (element == null) 3937 return; 3938 Complex t; 3939 if (Utilities.noString(parentType)) 3940 t = parent; 3941 else { 3942 t = parent.predicate("fhir:"+parentType+'.'+name); 3943 } 3944 composeBackboneElement(t, "dependsOn", name, element, index); 3945 if (element.hasPropertyElement()) 3946 composeUri(t, "ConceptMap", "property", element.getPropertyElement(), -1); 3947 if (element.hasSystemElement()) 3948 composeUri(t, "ConceptMap", "system", element.getSystemElement(), -1); 3949 if (element.hasCodeElement()) 3950 composeString(t, "ConceptMap", "code", element.getCodeElement(), -1); 3951 if (element.hasDisplayElement()) 3952 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 3953 } 3954 3955 protected void composeConceptMapConceptMapGroupUnmappedComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapGroupUnmappedComponent element, int index) { 3956 if (element == null) 3957 return; 3958 Complex t; 3959 if (Utilities.noString(parentType)) 3960 t = parent; 3961 else { 3962 t = parent.predicate("fhir:"+parentType+'.'+name); 3963 } 3964 composeBackboneElement(t, "unmapped", name, element, index); 3965 if (element.hasModeElement()) 3966 composeEnum(t, "ConceptMap", "mode", element.getModeElement(), -1); 3967 if (element.hasCodeElement()) 3968 composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1); 3969 if (element.hasDisplayElement()) 3970 composeString(t, "ConceptMap", "display", element.getDisplayElement(), -1); 3971 if (element.hasUrlElement()) 3972 composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1); 3973 } 3974 3975 protected void composeCondition(Complex parent, String parentType, String name, Condition element, int index) { 3976 if (element == null) 3977 return; 3978 Complex t; 3979 if (Utilities.noString(parentType)) 3980 t = parent; 3981 else { 3982 t = parent.predicate("fhir:"+parentType+'.'+name); 3983 } 3984 composeDomainResource(t, "Condition", name, element, index); 3985 for (int i = 0; i < element.getIdentifier().size(); i++) 3986 composeIdentifier(t, "Condition", "identifier", element.getIdentifier().get(i), i); 3987 if (element.hasClinicalStatusElement()) 3988 composeEnum(t, "Condition", "clinicalStatus", element.getClinicalStatusElement(), -1); 3989 if (element.hasVerificationStatusElement()) 3990 composeEnum(t, "Condition", "verificationStatus", element.getVerificationStatusElement(), -1); 3991 for (int i = 0; i < element.getCategory().size(); i++) 3992 composeCodeableConcept(t, "Condition", "category", element.getCategory().get(i), i); 3993 if (element.hasSeverity()) 3994 composeCodeableConcept(t, "Condition", "severity", element.getSeverity(), -1); 3995 if (element.hasCode()) 3996 composeCodeableConcept(t, "Condition", "code", element.getCode(), -1); 3997 for (int i = 0; i < element.getBodySite().size(); i++) 3998 composeCodeableConcept(t, "Condition", "bodySite", element.getBodySite().get(i), i); 3999 if (element.hasSubject()) 4000 composeReference(t, "Condition", "subject", element.getSubject(), -1); 4001 if (element.hasContext()) 4002 composeReference(t, "Condition", "context", element.getContext(), -1); 4003 if (element.hasOnset()) 4004 composeType(t, "Condition", "onset", element.getOnset(), -1); 4005 if (element.hasAbatement()) 4006 composeType(t, "Condition", "abatement", element.getAbatement(), -1); 4007 if (element.hasAssertedDateElement()) 4008 composeDateTime(t, "Condition", "assertedDate", element.getAssertedDateElement(), -1); 4009 if (element.hasAsserter()) 4010 composeReference(t, "Condition", "asserter", element.getAsserter(), -1); 4011 if (element.hasStage()) 4012 composeConditionConditionStageComponent(t, "Condition", "stage", element.getStage(), -1); 4013 for (int i = 0; i < element.getEvidence().size(); i++) 4014 composeConditionConditionEvidenceComponent(t, "Condition", "evidence", element.getEvidence().get(i), i); 4015 for (int i = 0; i < element.getNote().size(); i++) 4016 composeAnnotation(t, "Condition", "note", element.getNote().get(i), i); 4017 } 4018 4019 protected void composeConditionConditionStageComponent(Complex parent, String parentType, String name, Condition.ConditionStageComponent element, int index) { 4020 if (element == null) 4021 return; 4022 Complex t; 4023 if (Utilities.noString(parentType)) 4024 t = parent; 4025 else { 4026 t = parent.predicate("fhir:"+parentType+'.'+name); 4027 } 4028 composeBackboneElement(t, "stage", name, element, index); 4029 if (element.hasSummary()) 4030 composeCodeableConcept(t, "Condition", "summary", element.getSummary(), -1); 4031 for (int i = 0; i < element.getAssessment().size(); i++) 4032 composeReference(t, "Condition", "assessment", element.getAssessment().get(i), i); 4033 } 4034 4035 protected void composeConditionConditionEvidenceComponent(Complex parent, String parentType, String name, Condition.ConditionEvidenceComponent element, int index) { 4036 if (element == null) 4037 return; 4038 Complex t; 4039 if (Utilities.noString(parentType)) 4040 t = parent; 4041 else { 4042 t = parent.predicate("fhir:"+parentType+'.'+name); 4043 } 4044 composeBackboneElement(t, "evidence", name, element, index); 4045 for (int i = 0; i < element.getCode().size(); i++) 4046 composeCodeableConcept(t, "Condition", "code", element.getCode().get(i), i); 4047 for (int i = 0; i < element.getDetail().size(); i++) 4048 composeReference(t, "Condition", "detail", element.getDetail().get(i), i); 4049 } 4050 4051 protected void composeConsent(Complex parent, String parentType, String name, Consent element, int index) { 4052 if (element == null) 4053 return; 4054 Complex t; 4055 if (Utilities.noString(parentType)) 4056 t = parent; 4057 else { 4058 t = parent.predicate("fhir:"+parentType+'.'+name); 4059 } 4060 composeDomainResource(t, "Consent", name, element, index); 4061 if (element.hasIdentifier()) 4062 composeIdentifier(t, "Consent", "identifier", element.getIdentifier(), -1); 4063 if (element.hasStatusElement()) 4064 composeEnum(t, "Consent", "status", element.getStatusElement(), -1); 4065 for (int i = 0; i < element.getCategory().size(); i++) 4066 composeCodeableConcept(t, "Consent", "category", element.getCategory().get(i), i); 4067 if (element.hasPatient()) 4068 composeReference(t, "Consent", "patient", element.getPatient(), -1); 4069 if (element.hasPeriod()) 4070 composePeriod(t, "Consent", "period", element.getPeriod(), -1); 4071 if (element.hasDateTimeElement()) 4072 composeDateTime(t, "Consent", "dateTime", element.getDateTimeElement(), -1); 4073 for (int i = 0; i < element.getConsentingParty().size(); i++) 4074 composeReference(t, "Consent", "consentingParty", element.getConsentingParty().get(i), i); 4075 for (int i = 0; i < element.getActor().size(); i++) 4076 composeConsentConsentActorComponent(t, "Consent", "actor", element.getActor().get(i), i); 4077 for (int i = 0; i < element.getAction().size(); i++) 4078 composeCodeableConcept(t, "Consent", "action", element.getAction().get(i), i); 4079 for (int i = 0; i < element.getOrganization().size(); i++) 4080 composeReference(t, "Consent", "organization", element.getOrganization().get(i), i); 4081 if (element.hasSource()) 4082 composeType(t, "Consent", "source", element.getSource(), -1); 4083 for (int i = 0; i < element.getPolicy().size(); i++) 4084 composeConsentConsentPolicyComponent(t, "Consent", "policy", element.getPolicy().get(i), i); 4085 if (element.hasPolicyRuleElement()) 4086 composeUri(t, "Consent", "policyRule", element.getPolicyRuleElement(), -1); 4087 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4088 composeCoding(t, "Consent", "securityLabel", element.getSecurityLabel().get(i), i); 4089 for (int i = 0; i < element.getPurpose().size(); i++) 4090 composeCoding(t, "Consent", "purpose", element.getPurpose().get(i), i); 4091 if (element.hasDataPeriod()) 4092 composePeriod(t, "Consent", "dataPeriod", element.getDataPeriod(), -1); 4093 for (int i = 0; i < element.getData().size(); i++) 4094 composeConsentConsentDataComponent(t, "Consent", "data", element.getData().get(i), i); 4095 for (int i = 0; i < element.getExcept().size(); i++) 4096 composeConsentExceptComponent(t, "Consent", "except", element.getExcept().get(i), i); 4097 } 4098 4099 protected void composeConsentConsentActorComponent(Complex parent, String parentType, String name, Consent.ConsentActorComponent element, int index) { 4100 if (element == null) 4101 return; 4102 Complex t; 4103 if (Utilities.noString(parentType)) 4104 t = parent; 4105 else { 4106 t = parent.predicate("fhir:"+parentType+'.'+name); 4107 } 4108 composeBackboneElement(t, "actor", name, element, index); 4109 if (element.hasRole()) 4110 composeCodeableConcept(t, "Consent", "role", element.getRole(), -1); 4111 if (element.hasReference()) 4112 composeReference(t, "Consent", "reference", element.getReference(), -1); 4113 } 4114 4115 protected void composeConsentConsentPolicyComponent(Complex parent, String parentType, String name, Consent.ConsentPolicyComponent element, int index) { 4116 if (element == null) 4117 return; 4118 Complex t; 4119 if (Utilities.noString(parentType)) 4120 t = parent; 4121 else { 4122 t = parent.predicate("fhir:"+parentType+'.'+name); 4123 } 4124 composeBackboneElement(t, "policy", name, element, index); 4125 if (element.hasAuthorityElement()) 4126 composeUri(t, "Consent", "authority", element.getAuthorityElement(), -1); 4127 if (element.hasUriElement()) 4128 composeUri(t, "Consent", "uri", element.getUriElement(), -1); 4129 } 4130 4131 protected void composeConsentConsentDataComponent(Complex parent, String parentType, String name, Consent.ConsentDataComponent element, int index) { 4132 if (element == null) 4133 return; 4134 Complex t; 4135 if (Utilities.noString(parentType)) 4136 t = parent; 4137 else { 4138 t = parent.predicate("fhir:"+parentType+'.'+name); 4139 } 4140 composeBackboneElement(t, "data", name, element, index); 4141 if (element.hasMeaningElement()) 4142 composeEnum(t, "Consent", "meaning", element.getMeaningElement(), -1); 4143 if (element.hasReference()) 4144 composeReference(t, "Consent", "reference", element.getReference(), -1); 4145 } 4146 4147 protected void composeConsentExceptComponent(Complex parent, String parentType, String name, Consent.ExceptComponent element, int index) { 4148 if (element == null) 4149 return; 4150 Complex t; 4151 if (Utilities.noString(parentType)) 4152 t = parent; 4153 else { 4154 t = parent.predicate("fhir:"+parentType+'.'+name); 4155 } 4156 composeBackboneElement(t, "except", name, element, index); 4157 if (element.hasTypeElement()) 4158 composeEnum(t, "Consent", "type", element.getTypeElement(), -1); 4159 if (element.hasPeriod()) 4160 composePeriod(t, "Consent", "period", element.getPeriod(), -1); 4161 for (int i = 0; i < element.getActor().size(); i++) 4162 composeConsentExceptActorComponent(t, "Consent", "actor", element.getActor().get(i), i); 4163 for (int i = 0; i < element.getAction().size(); i++) 4164 composeCodeableConcept(t, "Consent", "action", element.getAction().get(i), i); 4165 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4166 composeCoding(t, "Consent", "securityLabel", element.getSecurityLabel().get(i), i); 4167 for (int i = 0; i < element.getPurpose().size(); i++) 4168 composeCoding(t, "Consent", "purpose", element.getPurpose().get(i), i); 4169 for (int i = 0; i < element.getClass_().size(); i++) 4170 composeCoding(t, "Consent", "class", element.getClass_().get(i), i); 4171 for (int i = 0; i < element.getCode().size(); i++) 4172 composeCoding(t, "Consent", "code", element.getCode().get(i), i); 4173 if (element.hasDataPeriod()) 4174 composePeriod(t, "Consent", "dataPeriod", element.getDataPeriod(), -1); 4175 for (int i = 0; i < element.getData().size(); i++) 4176 composeConsentExceptDataComponent(t, "Consent", "data", element.getData().get(i), i); 4177 } 4178 4179 protected void composeConsentExceptActorComponent(Complex parent, String parentType, String name, Consent.ExceptActorComponent element, int index) { 4180 if (element == null) 4181 return; 4182 Complex t; 4183 if (Utilities.noString(parentType)) 4184 t = parent; 4185 else { 4186 t = parent.predicate("fhir:"+parentType+'.'+name); 4187 } 4188 composeBackboneElement(t, "actor", name, element, index); 4189 if (element.hasRole()) 4190 composeCodeableConcept(t, "Consent", "role", element.getRole(), -1); 4191 if (element.hasReference()) 4192 composeReference(t, "Consent", "reference", element.getReference(), -1); 4193 } 4194 4195 protected void composeConsentExceptDataComponent(Complex parent, String parentType, String name, Consent.ExceptDataComponent element, int index) { 4196 if (element == null) 4197 return; 4198 Complex t; 4199 if (Utilities.noString(parentType)) 4200 t = parent; 4201 else { 4202 t = parent.predicate("fhir:"+parentType+'.'+name); 4203 } 4204 composeBackboneElement(t, "data", name, element, index); 4205 if (element.hasMeaningElement()) 4206 composeEnum(t, "Consent", "meaning", element.getMeaningElement(), -1); 4207 if (element.hasReference()) 4208 composeReference(t, "Consent", "reference", element.getReference(), -1); 4209 } 4210 4211 protected void composeContract(Complex parent, String parentType, String name, Contract element, int index) { 4212 if (element == null) 4213 return; 4214 Complex t; 4215 if (Utilities.noString(parentType)) 4216 t = parent; 4217 else { 4218 t = parent.predicate("fhir:"+parentType+'.'+name); 4219 } 4220 composeDomainResource(t, "Contract", name, element, index); 4221 if (element.hasIdentifier()) 4222 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 4223 if (element.hasStatusElement()) 4224 composeEnum(t, "Contract", "status", element.getStatusElement(), -1); 4225 if (element.hasIssuedElement()) 4226 composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1); 4227 if (element.hasApplies()) 4228 composePeriod(t, "Contract", "applies", element.getApplies(), -1); 4229 for (int i = 0; i < element.getSubject().size(); i++) 4230 composeReference(t, "Contract", "subject", element.getSubject().get(i), i); 4231 for (int i = 0; i < element.getTopic().size(); i++) 4232 composeReference(t, "Contract", "topic", element.getTopic().get(i), i); 4233 for (int i = 0; i < element.getAuthority().size(); i++) 4234 composeReference(t, "Contract", "authority", element.getAuthority().get(i), i); 4235 for (int i = 0; i < element.getDomain().size(); i++) 4236 composeReference(t, "Contract", "domain", element.getDomain().get(i), i); 4237 if (element.hasType()) 4238 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 4239 for (int i = 0; i < element.getSubType().size(); i++) 4240 composeCodeableConcept(t, "Contract", "subType", element.getSubType().get(i), i); 4241 for (int i = 0; i < element.getAction().size(); i++) 4242 composeCodeableConcept(t, "Contract", "action", element.getAction().get(i), i); 4243 for (int i = 0; i < element.getActionReason().size(); i++) 4244 composeCodeableConcept(t, "Contract", "actionReason", element.getActionReason().get(i), i); 4245 if (element.hasDecisionType()) 4246 composeCodeableConcept(t, "Contract", "decisionType", element.getDecisionType(), -1); 4247 if (element.hasContentDerivative()) 4248 composeCodeableConcept(t, "Contract", "contentDerivative", element.getContentDerivative(), -1); 4249 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4250 composeCoding(t, "Contract", "securityLabel", element.getSecurityLabel().get(i), i); 4251 for (int i = 0; i < element.getAgent().size(); i++) 4252 composeContractAgentComponent(t, "Contract", "agent", element.getAgent().get(i), i); 4253 for (int i = 0; i < element.getSigner().size(); i++) 4254 composeContractSignatoryComponent(t, "Contract", "signer", element.getSigner().get(i), i); 4255 for (int i = 0; i < element.getValuedItem().size(); i++) 4256 composeContractValuedItemComponent(t, "Contract", "valuedItem", element.getValuedItem().get(i), i); 4257 for (int i = 0; i < element.getTerm().size(); i++) 4258 composeContractTermComponent(t, "Contract", "term", element.getTerm().get(i), i); 4259 if (element.hasBinding()) 4260 composeType(t, "Contract", "binding", element.getBinding(), -1); 4261 for (int i = 0; i < element.getFriendly().size(); i++) 4262 composeContractFriendlyLanguageComponent(t, "Contract", "friendly", element.getFriendly().get(i), i); 4263 for (int i = 0; i < element.getLegal().size(); i++) 4264 composeContractLegalLanguageComponent(t, "Contract", "legal", element.getLegal().get(i), i); 4265 for (int i = 0; i < element.getRule().size(); i++) 4266 composeContractComputableLanguageComponent(t, "Contract", "rule", element.getRule().get(i), i); 4267 } 4268 4269 protected void composeContractAgentComponent(Complex parent, String parentType, String name, Contract.AgentComponent element, int index) { 4270 if (element == null) 4271 return; 4272 Complex t; 4273 if (Utilities.noString(parentType)) 4274 t = parent; 4275 else { 4276 t = parent.predicate("fhir:"+parentType+'.'+name); 4277 } 4278 composeBackboneElement(t, "agent", name, element, index); 4279 if (element.hasActor()) 4280 composeReference(t, "Contract", "actor", element.getActor(), -1); 4281 for (int i = 0; i < element.getRole().size(); i++) 4282 composeCodeableConcept(t, "Contract", "role", element.getRole().get(i), i); 4283 } 4284 4285 protected void composeContractSignatoryComponent(Complex parent, String parentType, String name, Contract.SignatoryComponent element, int index) { 4286 if (element == null) 4287 return; 4288 Complex t; 4289 if (Utilities.noString(parentType)) 4290 t = parent; 4291 else { 4292 t = parent.predicate("fhir:"+parentType+'.'+name); 4293 } 4294 composeBackboneElement(t, "signer", name, element, index); 4295 if (element.hasType()) 4296 composeCoding(t, "Contract", "type", element.getType(), -1); 4297 if (element.hasParty()) 4298 composeReference(t, "Contract", "party", element.getParty(), -1); 4299 for (int i = 0; i < element.getSignature().size(); i++) 4300 composeSignature(t, "Contract", "signature", element.getSignature().get(i), i); 4301 } 4302 4303 protected void composeContractValuedItemComponent(Complex parent, String parentType, String name, Contract.ValuedItemComponent element, int index) { 4304 if (element == null) 4305 return; 4306 Complex t; 4307 if (Utilities.noString(parentType)) 4308 t = parent; 4309 else { 4310 t = parent.predicate("fhir:"+parentType+'.'+name); 4311 } 4312 composeBackboneElement(t, "valuedItem", name, element, index); 4313 if (element.hasEntity()) 4314 composeType(t, "Contract", "entity", element.getEntity(), -1); 4315 if (element.hasIdentifier()) 4316 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 4317 if (element.hasEffectiveTimeElement()) 4318 composeDateTime(t, "Contract", "effectiveTime", element.getEffectiveTimeElement(), -1); 4319 if (element.hasQuantity()) 4320 composeQuantity(t, "Contract", "quantity", element.getQuantity(), -1); 4321 if (element.hasUnitPrice()) 4322 composeMoney(t, "Contract", "unitPrice", element.getUnitPrice(), -1); 4323 if (element.hasFactorElement()) 4324 composeDecimal(t, "Contract", "factor", element.getFactorElement(), -1); 4325 if (element.hasPointsElement()) 4326 composeDecimal(t, "Contract", "points", element.getPointsElement(), -1); 4327 if (element.hasNet()) 4328 composeMoney(t, "Contract", "net", element.getNet(), -1); 4329 } 4330 4331 protected void composeContractTermComponent(Complex parent, String parentType, String name, Contract.TermComponent element, int index) { 4332 if (element == null) 4333 return; 4334 Complex t; 4335 if (Utilities.noString(parentType)) 4336 t = parent; 4337 else { 4338 t = parent.predicate("fhir:"+parentType+'.'+name); 4339 } 4340 composeBackboneElement(t, "term", name, element, index); 4341 if (element.hasIdentifier()) 4342 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 4343 if (element.hasIssuedElement()) 4344 composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1); 4345 if (element.hasApplies()) 4346 composePeriod(t, "Contract", "applies", element.getApplies(), -1); 4347 if (element.hasType()) 4348 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 4349 if (element.hasSubType()) 4350 composeCodeableConcept(t, "Contract", "subType", element.getSubType(), -1); 4351 for (int i = 0; i < element.getTopic().size(); i++) 4352 composeReference(t, "Contract", "topic", element.getTopic().get(i), i); 4353 for (int i = 0; i < element.getAction().size(); i++) 4354 composeCodeableConcept(t, "Contract", "action", element.getAction().get(i), i); 4355 for (int i = 0; i < element.getActionReason().size(); i++) 4356 composeCodeableConcept(t, "Contract", "actionReason", element.getActionReason().get(i), i); 4357 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4358 composeCoding(t, "Contract", "securityLabel", element.getSecurityLabel().get(i), i); 4359 for (int i = 0; i < element.getAgent().size(); i++) 4360 composeContractTermAgentComponent(t, "Contract", "agent", element.getAgent().get(i), i); 4361 if (element.hasTextElement()) 4362 composeString(t, "Contract", "text", element.getTextElement(), -1); 4363 for (int i = 0; i < element.getValuedItem().size(); i++) 4364 composeContractTermValuedItemComponent(t, "Contract", "valuedItem", element.getValuedItem().get(i), i); 4365 for (int i = 0; i < element.getGroup().size(); i++) 4366 composeContractTermComponent(t, "Contract", "group", element.getGroup().get(i), i); 4367 } 4368 4369 protected void composeContractTermAgentComponent(Complex parent, String parentType, String name, Contract.TermAgentComponent element, int index) { 4370 if (element == null) 4371 return; 4372 Complex t; 4373 if (Utilities.noString(parentType)) 4374 t = parent; 4375 else { 4376 t = parent.predicate("fhir:"+parentType+'.'+name); 4377 } 4378 composeBackboneElement(t, "agent", name, element, index); 4379 if (element.hasActor()) 4380 composeReference(t, "Contract", "actor", element.getActor(), -1); 4381 for (int i = 0; i < element.getRole().size(); i++) 4382 composeCodeableConcept(t, "Contract", "role", element.getRole().get(i), i); 4383 } 4384 4385 protected void composeContractTermValuedItemComponent(Complex parent, String parentType, String name, Contract.TermValuedItemComponent element, int index) { 4386 if (element == null) 4387 return; 4388 Complex t; 4389 if (Utilities.noString(parentType)) 4390 t = parent; 4391 else { 4392 t = parent.predicate("fhir:"+parentType+'.'+name); 4393 } 4394 composeBackboneElement(t, "valuedItem", name, element, index); 4395 if (element.hasEntity()) 4396 composeType(t, "Contract", "entity", element.getEntity(), -1); 4397 if (element.hasIdentifier()) 4398 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 4399 if (element.hasEffectiveTimeElement()) 4400 composeDateTime(t, "Contract", "effectiveTime", element.getEffectiveTimeElement(), -1); 4401 if (element.hasQuantity()) 4402 composeQuantity(t, "Contract", "quantity", element.getQuantity(), -1); 4403 if (element.hasUnitPrice()) 4404 composeMoney(t, "Contract", "unitPrice", element.getUnitPrice(), -1); 4405 if (element.hasFactorElement()) 4406 composeDecimal(t, "Contract", "factor", element.getFactorElement(), -1); 4407 if (element.hasPointsElement()) 4408 composeDecimal(t, "Contract", "points", element.getPointsElement(), -1); 4409 if (element.hasNet()) 4410 composeMoney(t, "Contract", "net", element.getNet(), -1); 4411 } 4412 4413 protected void composeContractFriendlyLanguageComponent(Complex parent, String parentType, String name, Contract.FriendlyLanguageComponent element, int index) { 4414 if (element == null) 4415 return; 4416 Complex t; 4417 if (Utilities.noString(parentType)) 4418 t = parent; 4419 else { 4420 t = parent.predicate("fhir:"+parentType+'.'+name); 4421 } 4422 composeBackboneElement(t, "friendly", name, element, index); 4423 if (element.hasContent()) 4424 composeType(t, "Contract", "content", element.getContent(), -1); 4425 } 4426 4427 protected void composeContractLegalLanguageComponent(Complex parent, String parentType, String name, Contract.LegalLanguageComponent element, int index) { 4428 if (element == null) 4429 return; 4430 Complex t; 4431 if (Utilities.noString(parentType)) 4432 t = parent; 4433 else { 4434 t = parent.predicate("fhir:"+parentType+'.'+name); 4435 } 4436 composeBackboneElement(t, "legal", name, element, index); 4437 if (element.hasContent()) 4438 composeType(t, "Contract", "content", element.getContent(), -1); 4439 } 4440 4441 protected void composeContractComputableLanguageComponent(Complex parent, String parentType, String name, Contract.ComputableLanguageComponent element, int index) { 4442 if (element == null) 4443 return; 4444 Complex t; 4445 if (Utilities.noString(parentType)) 4446 t = parent; 4447 else { 4448 t = parent.predicate("fhir:"+parentType+'.'+name); 4449 } 4450 composeBackboneElement(t, "rule", name, element, index); 4451 if (element.hasContent()) 4452 composeType(t, "Contract", "content", element.getContent(), -1); 4453 } 4454 4455 protected void composeCoverage(Complex parent, String parentType, String name, Coverage element, int index) { 4456 if (element == null) 4457 return; 4458 Complex t; 4459 if (Utilities.noString(parentType)) 4460 t = parent; 4461 else { 4462 t = parent.predicate("fhir:"+parentType+'.'+name); 4463 } 4464 composeDomainResource(t, "Coverage", name, element, index); 4465 for (int i = 0; i < element.getIdentifier().size(); i++) 4466 composeIdentifier(t, "Coverage", "identifier", element.getIdentifier().get(i), i); 4467 if (element.hasStatusElement()) 4468 composeEnum(t, "Coverage", "status", element.getStatusElement(), -1); 4469 if (element.hasType()) 4470 composeCodeableConcept(t, "Coverage", "type", element.getType(), -1); 4471 if (element.hasPolicyHolder()) 4472 composeReference(t, "Coverage", "policyHolder", element.getPolicyHolder(), -1); 4473 if (element.hasSubscriber()) 4474 composeReference(t, "Coverage", "subscriber", element.getSubscriber(), -1); 4475 if (element.hasSubscriberIdElement()) 4476 composeString(t, "Coverage", "subscriberId", element.getSubscriberIdElement(), -1); 4477 if (element.hasBeneficiary()) 4478 composeReference(t, "Coverage", "beneficiary", element.getBeneficiary(), -1); 4479 if (element.hasRelationship()) 4480 composeCodeableConcept(t, "Coverage", "relationship", element.getRelationship(), -1); 4481 if (element.hasPeriod()) 4482 composePeriod(t, "Coverage", "period", element.getPeriod(), -1); 4483 for (int i = 0; i < element.getPayor().size(); i++) 4484 composeReference(t, "Coverage", "payor", element.getPayor().get(i), i); 4485 if (element.hasGrouping()) 4486 composeCoverageGroupComponent(t, "Coverage", "grouping", element.getGrouping(), -1); 4487 if (element.hasDependentElement()) 4488 composeString(t, "Coverage", "dependent", element.getDependentElement(), -1); 4489 if (element.hasSequenceElement()) 4490 composeString(t, "Coverage", "sequence", element.getSequenceElement(), -1); 4491 if (element.hasOrderElement()) 4492 composePositiveInt(t, "Coverage", "order", element.getOrderElement(), -1); 4493 if (element.hasNetworkElement()) 4494 composeString(t, "Coverage", "network", element.getNetworkElement(), -1); 4495 for (int i = 0; i < element.getContract().size(); i++) 4496 composeReference(t, "Coverage", "contract", element.getContract().get(i), i); 4497 } 4498 4499 protected void composeCoverageGroupComponent(Complex parent, String parentType, String name, Coverage.GroupComponent element, int index) { 4500 if (element == null) 4501 return; 4502 Complex t; 4503 if (Utilities.noString(parentType)) 4504 t = parent; 4505 else { 4506 t = parent.predicate("fhir:"+parentType+'.'+name); 4507 } 4508 composeBackboneElement(t, "grouping", name, element, index); 4509 if (element.hasGroupElement()) 4510 composeString(t, "Coverage", "group", element.getGroupElement(), -1); 4511 if (element.hasGroupDisplayElement()) 4512 composeString(t, "Coverage", "groupDisplay", element.getGroupDisplayElement(), -1); 4513 if (element.hasSubGroupElement()) 4514 composeString(t, "Coverage", "subGroup", element.getSubGroupElement(), -1); 4515 if (element.hasSubGroupDisplayElement()) 4516 composeString(t, "Coverage", "subGroupDisplay", element.getSubGroupDisplayElement(), -1); 4517 if (element.hasPlanElement()) 4518 composeString(t, "Coverage", "plan", element.getPlanElement(), -1); 4519 if (element.hasPlanDisplayElement()) 4520 composeString(t, "Coverage", "planDisplay", element.getPlanDisplayElement(), -1); 4521 if (element.hasSubPlanElement()) 4522 composeString(t, "Coverage", "subPlan", element.getSubPlanElement(), -1); 4523 if (element.hasSubPlanDisplayElement()) 4524 composeString(t, "Coverage", "subPlanDisplay", element.getSubPlanDisplayElement(), -1); 4525 if (element.hasClass_Element()) 4526 composeString(t, "Coverage", "class", element.getClass_Element(), -1); 4527 if (element.hasClassDisplayElement()) 4528 composeString(t, "Coverage", "classDisplay", element.getClassDisplayElement(), -1); 4529 if (element.hasSubClassElement()) 4530 composeString(t, "Coverage", "subClass", element.getSubClassElement(), -1); 4531 if (element.hasSubClassDisplayElement()) 4532 composeString(t, "Coverage", "subClassDisplay", element.getSubClassDisplayElement(), -1); 4533 } 4534 4535 protected void composeDataElement(Complex parent, String parentType, String name, DataElement element, int index) { 4536 if (element == null) 4537 return; 4538 Complex t; 4539 if (Utilities.noString(parentType)) 4540 t = parent; 4541 else { 4542 t = parent.predicate("fhir:"+parentType+'.'+name); 4543 } 4544 composeDomainResource(t, "DataElement", name, element, index); 4545 if (element.hasUrlElement()) 4546 composeUri(t, "DataElement", "url", element.getUrlElement(), -1); 4547 for (int i = 0; i < element.getIdentifier().size(); i++) 4548 composeIdentifier(t, "DataElement", "identifier", element.getIdentifier().get(i), i); 4549 if (element.hasVersionElement()) 4550 composeString(t, "DataElement", "version", element.getVersionElement(), -1); 4551 if (element.hasStatusElement()) 4552 composeEnum(t, "DataElement", "status", element.getStatusElement(), -1); 4553 if (element.hasExperimentalElement()) 4554 composeBoolean(t, "DataElement", "experimental", element.getExperimentalElement(), -1); 4555 if (element.hasDateElement()) 4556 composeDateTime(t, "DataElement", "date", element.getDateElement(), -1); 4557 if (element.hasPublisherElement()) 4558 composeString(t, "DataElement", "publisher", element.getPublisherElement(), -1); 4559 if (element.hasNameElement()) 4560 composeString(t, "DataElement", "name", element.getNameElement(), -1); 4561 if (element.hasTitleElement()) 4562 composeString(t, "DataElement", "title", element.getTitleElement(), -1); 4563 for (int i = 0; i < element.getContact().size(); i++) 4564 composeContactDetail(t, "DataElement", "contact", element.getContact().get(i), i); 4565 for (int i = 0; i < element.getUseContext().size(); i++) 4566 composeUsageContext(t, "DataElement", "useContext", element.getUseContext().get(i), i); 4567 for (int i = 0; i < element.getJurisdiction().size(); i++) 4568 composeCodeableConcept(t, "DataElement", "jurisdiction", element.getJurisdiction().get(i), i); 4569 if (element.hasCopyrightElement()) 4570 composeMarkdown(t, "DataElement", "copyright", element.getCopyrightElement(), -1); 4571 if (element.hasStringencyElement()) 4572 composeEnum(t, "DataElement", "stringency", element.getStringencyElement(), -1); 4573 for (int i = 0; i < element.getMapping().size(); i++) 4574 composeDataElementDataElementMappingComponent(t, "DataElement", "mapping", element.getMapping().get(i), i); 4575 for (int i = 0; i < element.getElement().size(); i++) 4576 composeElementDefinition(t, "DataElement", "element", element.getElement().get(i), i); 4577 } 4578 4579 protected void composeDataElementDataElementMappingComponent(Complex parent, String parentType, String name, DataElement.DataElementMappingComponent element, int index) { 4580 if (element == null) 4581 return; 4582 Complex t; 4583 if (Utilities.noString(parentType)) 4584 t = parent; 4585 else { 4586 t = parent.predicate("fhir:"+parentType+'.'+name); 4587 } 4588 composeBackboneElement(t, "mapping", name, element, index); 4589 if (element.hasIdentityElement()) 4590 composeId(t, "DataElement", "identity", element.getIdentityElement(), -1); 4591 if (element.hasUriElement()) 4592 composeUri(t, "DataElement", "uri", element.getUriElement(), -1); 4593 if (element.hasNameElement()) 4594 composeString(t, "DataElement", "name", element.getNameElement(), -1); 4595 if (element.hasCommentElement()) 4596 composeString(t, "DataElement", "comment", element.getCommentElement(), -1); 4597 } 4598 4599 protected void composeDetectedIssue(Complex parent, String parentType, String name, DetectedIssue element, int index) { 4600 if (element == null) 4601 return; 4602 Complex t; 4603 if (Utilities.noString(parentType)) 4604 t = parent; 4605 else { 4606 t = parent.predicate("fhir:"+parentType+'.'+name); 4607 } 4608 composeDomainResource(t, "DetectedIssue", name, element, index); 4609 if (element.hasIdentifier()) 4610 composeIdentifier(t, "DetectedIssue", "identifier", element.getIdentifier(), -1); 4611 if (element.hasStatusElement()) 4612 composeEnum(t, "DetectedIssue", "status", element.getStatusElement(), -1); 4613 if (element.hasCategory()) 4614 composeCodeableConcept(t, "DetectedIssue", "category", element.getCategory(), -1); 4615 if (element.hasSeverityElement()) 4616 composeEnum(t, "DetectedIssue", "severity", element.getSeverityElement(), -1); 4617 if (element.hasPatient()) 4618 composeReference(t, "DetectedIssue", "patient", element.getPatient(), -1); 4619 if (element.hasDateElement()) 4620 composeDateTime(t, "DetectedIssue", "date", element.getDateElement(), -1); 4621 if (element.hasAuthor()) 4622 composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1); 4623 for (int i = 0; i < element.getImplicated().size(); i++) 4624 composeReference(t, "DetectedIssue", "implicated", element.getImplicated().get(i), i); 4625 if (element.hasDetailElement()) 4626 composeString(t, "DetectedIssue", "detail", element.getDetailElement(), -1); 4627 if (element.hasReferenceElement()) 4628 composeUri(t, "DetectedIssue", "reference", element.getReferenceElement(), -1); 4629 for (int i = 0; i < element.getMitigation().size(); i++) 4630 composeDetectedIssueDetectedIssueMitigationComponent(t, "DetectedIssue", "mitigation", element.getMitigation().get(i), i); 4631 } 4632 4633 protected void composeDetectedIssueDetectedIssueMitigationComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueMitigationComponent element, int index) { 4634 if (element == null) 4635 return; 4636 Complex t; 4637 if (Utilities.noString(parentType)) 4638 t = parent; 4639 else { 4640 t = parent.predicate("fhir:"+parentType+'.'+name); 4641 } 4642 composeBackboneElement(t, "mitigation", name, element, index); 4643 if (element.hasAction()) 4644 composeCodeableConcept(t, "DetectedIssue", "action", element.getAction(), -1); 4645 if (element.hasDateElement()) 4646 composeDateTime(t, "DetectedIssue", "date", element.getDateElement(), -1); 4647 if (element.hasAuthor()) 4648 composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1); 4649 } 4650 4651 protected void composeDevice(Complex parent, String parentType, String name, Device element, int index) { 4652 if (element == null) 4653 return; 4654 Complex t; 4655 if (Utilities.noString(parentType)) 4656 t = parent; 4657 else { 4658 t = parent.predicate("fhir:"+parentType+'.'+name); 4659 } 4660 composeDomainResource(t, "Device", name, element, index); 4661 for (int i = 0; i < element.getIdentifier().size(); i++) 4662 composeIdentifier(t, "Device", "identifier", element.getIdentifier().get(i), i); 4663 if (element.hasUdi()) 4664 composeDeviceDeviceUdiComponent(t, "Device", "udi", element.getUdi(), -1); 4665 if (element.hasStatusElement()) 4666 composeEnum(t, "Device", "status", element.getStatusElement(), -1); 4667 if (element.hasType()) 4668 composeCodeableConcept(t, "Device", "type", element.getType(), -1); 4669 if (element.hasLotNumberElement()) 4670 composeString(t, "Device", "lotNumber", element.getLotNumberElement(), -1); 4671 if (element.hasManufacturerElement()) 4672 composeString(t, "Device", "manufacturer", element.getManufacturerElement(), -1); 4673 if (element.hasManufactureDateElement()) 4674 composeDateTime(t, "Device", "manufactureDate", element.getManufactureDateElement(), -1); 4675 if (element.hasExpirationDateElement()) 4676 composeDateTime(t, "Device", "expirationDate", element.getExpirationDateElement(), -1); 4677 if (element.hasModelElement()) 4678 composeString(t, "Device", "model", element.getModelElement(), -1); 4679 if (element.hasVersionElement()) 4680 composeString(t, "Device", "version", element.getVersionElement(), -1); 4681 if (element.hasPatient()) 4682 composeReference(t, "Device", "patient", element.getPatient(), -1); 4683 if (element.hasOwner()) 4684 composeReference(t, "Device", "owner", element.getOwner(), -1); 4685 for (int i = 0; i < element.getContact().size(); i++) 4686 composeContactPoint(t, "Device", "contact", element.getContact().get(i), i); 4687 if (element.hasLocation()) 4688 composeReference(t, "Device", "location", element.getLocation(), -1); 4689 if (element.hasUrlElement()) 4690 composeUri(t, "Device", "url", element.getUrlElement(), -1); 4691 for (int i = 0; i < element.getNote().size(); i++) 4692 composeAnnotation(t, "Device", "note", element.getNote().get(i), i); 4693 for (int i = 0; i < element.getSafety().size(); i++) 4694 composeCodeableConcept(t, "Device", "safety", element.getSafety().get(i), i); 4695 } 4696 4697 protected void composeDeviceDeviceUdiComponent(Complex parent, String parentType, String name, Device.DeviceUdiComponent element, int index) { 4698 if (element == null) 4699 return; 4700 Complex t; 4701 if (Utilities.noString(parentType)) 4702 t = parent; 4703 else { 4704 t = parent.predicate("fhir:"+parentType+'.'+name); 4705 } 4706 composeBackboneElement(t, "udi", name, element, index); 4707 if (element.hasDeviceIdentifierElement()) 4708 composeString(t, "Device", "deviceIdentifier", element.getDeviceIdentifierElement(), -1); 4709 if (element.hasNameElement()) 4710 composeString(t, "Device", "name", element.getNameElement(), -1); 4711 if (element.hasJurisdictionElement()) 4712 composeUri(t, "Device", "jurisdiction", element.getJurisdictionElement(), -1); 4713 if (element.hasCarrierHRFElement()) 4714 composeString(t, "Device", "carrierHRF", element.getCarrierHRFElement(), -1); 4715 if (element.hasCarrierAIDCElement()) 4716 composeBase64Binary(t, "Device", "carrierAIDC", element.getCarrierAIDCElement(), -1); 4717 if (element.hasIssuerElement()) 4718 composeUri(t, "Device", "issuer", element.getIssuerElement(), -1); 4719 if (element.hasEntryTypeElement()) 4720 composeEnum(t, "Device", "entryType", element.getEntryTypeElement(), -1); 4721 } 4722 4723 protected void composeDeviceComponent(Complex parent, String parentType, String name, DeviceComponent element, int index) { 4724 if (element == null) 4725 return; 4726 Complex t; 4727 if (Utilities.noString(parentType)) 4728 t = parent; 4729 else { 4730 t = parent.predicate("fhir:"+parentType+'.'+name); 4731 } 4732 composeDomainResource(t, "DeviceComponent", name, element, index); 4733 if (element.hasIdentifier()) 4734 composeIdentifier(t, "DeviceComponent", "identifier", element.getIdentifier(), -1); 4735 if (element.hasType()) 4736 composeCodeableConcept(t, "DeviceComponent", "type", element.getType(), -1); 4737 if (element.hasLastSystemChangeElement()) 4738 composeInstant(t, "DeviceComponent", "lastSystemChange", element.getLastSystemChangeElement(), -1); 4739 if (element.hasSource()) 4740 composeReference(t, "DeviceComponent", "source", element.getSource(), -1); 4741 if (element.hasParent()) 4742 composeReference(t, "DeviceComponent", "parent", element.getParent(), -1); 4743 for (int i = 0; i < element.getOperationalStatus().size(); i++) 4744 composeCodeableConcept(t, "DeviceComponent", "operationalStatus", element.getOperationalStatus().get(i), i); 4745 if (element.hasParameterGroup()) 4746 composeCodeableConcept(t, "DeviceComponent", "parameterGroup", element.getParameterGroup(), -1); 4747 if (element.hasMeasurementPrincipleElement()) 4748 composeEnum(t, "DeviceComponent", "measurementPrinciple", element.getMeasurementPrincipleElement(), -1); 4749 for (int i = 0; i < element.getProductionSpecification().size(); i++) 4750 composeDeviceComponentDeviceComponentProductionSpecificationComponent(t, "DeviceComponent", "productionSpecification", element.getProductionSpecification().get(i), i); 4751 if (element.hasLanguageCode()) 4752 composeCodeableConcept(t, "DeviceComponent", "languageCode", element.getLanguageCode(), -1); 4753 } 4754 4755 protected void composeDeviceComponentDeviceComponentProductionSpecificationComponent(Complex parent, String parentType, String name, DeviceComponent.DeviceComponentProductionSpecificationComponent element, int index) { 4756 if (element == null) 4757 return; 4758 Complex t; 4759 if (Utilities.noString(parentType)) 4760 t = parent; 4761 else { 4762 t = parent.predicate("fhir:"+parentType+'.'+name); 4763 } 4764 composeBackboneElement(t, "productionSpecification", name, element, index); 4765 if (element.hasSpecType()) 4766 composeCodeableConcept(t, "DeviceComponent", "specType", element.getSpecType(), -1); 4767 if (element.hasComponentId()) 4768 composeIdentifier(t, "DeviceComponent", "componentId", element.getComponentId(), -1); 4769 if (element.hasProductionSpecElement()) 4770 composeString(t, "DeviceComponent", "productionSpec", element.getProductionSpecElement(), -1); 4771 } 4772 4773 protected void composeDeviceMetric(Complex parent, String parentType, String name, DeviceMetric element, int index) { 4774 if (element == null) 4775 return; 4776 Complex t; 4777 if (Utilities.noString(parentType)) 4778 t = parent; 4779 else { 4780 t = parent.predicate("fhir:"+parentType+'.'+name); 4781 } 4782 composeDomainResource(t, "DeviceMetric", name, element, index); 4783 if (element.hasIdentifier()) 4784 composeIdentifier(t, "DeviceMetric", "identifier", element.getIdentifier(), -1); 4785 if (element.hasType()) 4786 composeCodeableConcept(t, "DeviceMetric", "type", element.getType(), -1); 4787 if (element.hasUnit()) 4788 composeCodeableConcept(t, "DeviceMetric", "unit", element.getUnit(), -1); 4789 if (element.hasSource()) 4790 composeReference(t, "DeviceMetric", "source", element.getSource(), -1); 4791 if (element.hasParent()) 4792 composeReference(t, "DeviceMetric", "parent", element.getParent(), -1); 4793 if (element.hasOperationalStatusElement()) 4794 composeEnum(t, "DeviceMetric", "operationalStatus", element.getOperationalStatusElement(), -1); 4795 if (element.hasColorElement()) 4796 composeEnum(t, "DeviceMetric", "color", element.getColorElement(), -1); 4797 if (element.hasCategoryElement()) 4798 composeEnum(t, "DeviceMetric", "category", element.getCategoryElement(), -1); 4799 if (element.hasMeasurementPeriod()) 4800 composeTiming(t, "DeviceMetric", "measurementPeriod", element.getMeasurementPeriod(), -1); 4801 for (int i = 0; i < element.getCalibration().size(); i++) 4802 composeDeviceMetricDeviceMetricCalibrationComponent(t, "DeviceMetric", "calibration", element.getCalibration().get(i), i); 4803 } 4804 4805 protected void composeDeviceMetricDeviceMetricCalibrationComponent(Complex parent, String parentType, String name, DeviceMetric.DeviceMetricCalibrationComponent element, int index) { 4806 if (element == null) 4807 return; 4808 Complex t; 4809 if (Utilities.noString(parentType)) 4810 t = parent; 4811 else { 4812 t = parent.predicate("fhir:"+parentType+'.'+name); 4813 } 4814 composeBackboneElement(t, "calibration", name, element, index); 4815 if (element.hasTypeElement()) 4816 composeEnum(t, "DeviceMetric", "type", element.getTypeElement(), -1); 4817 if (element.hasStateElement()) 4818 composeEnum(t, "DeviceMetric", "state", element.getStateElement(), -1); 4819 if (element.hasTimeElement()) 4820 composeInstant(t, "DeviceMetric", "time", element.getTimeElement(), -1); 4821 } 4822 4823 protected void composeDeviceRequest(Complex parent, String parentType, String name, DeviceRequest element, int index) { 4824 if (element == null) 4825 return; 4826 Complex t; 4827 if (Utilities.noString(parentType)) 4828 t = parent; 4829 else { 4830 t = parent.predicate("fhir:"+parentType+'.'+name); 4831 } 4832 composeDomainResource(t, "DeviceRequest", name, element, index); 4833 for (int i = 0; i < element.getIdentifier().size(); i++) 4834 composeIdentifier(t, "DeviceRequest", "identifier", element.getIdentifier().get(i), i); 4835 for (int i = 0; i < element.getDefinition().size(); i++) 4836 composeReference(t, "DeviceRequest", "definition", element.getDefinition().get(i), i); 4837 for (int i = 0; i < element.getBasedOn().size(); i++) 4838 composeReference(t, "DeviceRequest", "basedOn", element.getBasedOn().get(i), i); 4839 for (int i = 0; i < element.getPriorRequest().size(); i++) 4840 composeReference(t, "DeviceRequest", "priorRequest", element.getPriorRequest().get(i), i); 4841 if (element.hasGroupIdentifier()) 4842 composeIdentifier(t, "DeviceRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 4843 if (element.hasStatusElement()) 4844 composeEnum(t, "DeviceRequest", "status", element.getStatusElement(), -1); 4845 if (element.hasIntent()) 4846 composeCodeableConcept(t, "DeviceRequest", "intent", element.getIntent(), -1); 4847 if (element.hasPriorityElement()) 4848 composeEnum(t, "DeviceRequest", "priority", element.getPriorityElement(), -1); 4849 if (element.hasCode()) 4850 composeType(t, "DeviceRequest", "code", element.getCode(), -1); 4851 if (element.hasSubject()) 4852 composeReference(t, "DeviceRequest", "subject", element.getSubject(), -1); 4853 if (element.hasContext()) 4854 composeReference(t, "DeviceRequest", "context", element.getContext(), -1); 4855 if (element.hasOccurrence()) 4856 composeType(t, "DeviceRequest", "occurrence", element.getOccurrence(), -1); 4857 if (element.hasAuthoredOnElement()) 4858 composeDateTime(t, "DeviceRequest", "authoredOn", element.getAuthoredOnElement(), -1); 4859 if (element.hasRequester()) 4860 composeDeviceRequestDeviceRequestRequesterComponent(t, "DeviceRequest", "requester", element.getRequester(), -1); 4861 if (element.hasPerformerType()) 4862 composeCodeableConcept(t, "DeviceRequest", "performerType", element.getPerformerType(), -1); 4863 if (element.hasPerformer()) 4864 composeReference(t, "DeviceRequest", "performer", element.getPerformer(), -1); 4865 for (int i = 0; i < element.getReasonCode().size(); i++) 4866 composeCodeableConcept(t, "DeviceRequest", "reasonCode", element.getReasonCode().get(i), i); 4867 for (int i = 0; i < element.getReasonReference().size(); i++) 4868 composeReference(t, "DeviceRequest", "reasonReference", element.getReasonReference().get(i), i); 4869 for (int i = 0; i < element.getSupportingInfo().size(); i++) 4870 composeReference(t, "DeviceRequest", "supportingInfo", element.getSupportingInfo().get(i), i); 4871 for (int i = 0; i < element.getNote().size(); i++) 4872 composeAnnotation(t, "DeviceRequest", "note", element.getNote().get(i), i); 4873 for (int i = 0; i < element.getRelevantHistory().size(); i++) 4874 composeReference(t, "DeviceRequest", "relevantHistory", element.getRelevantHistory().get(i), i); 4875 } 4876 4877 protected void composeDeviceRequestDeviceRequestRequesterComponent(Complex parent, String parentType, String name, DeviceRequest.DeviceRequestRequesterComponent element, int index) { 4878 if (element == null) 4879 return; 4880 Complex t; 4881 if (Utilities.noString(parentType)) 4882 t = parent; 4883 else { 4884 t = parent.predicate("fhir:"+parentType+'.'+name); 4885 } 4886 composeBackboneElement(t, "requester", name, element, index); 4887 if (element.hasAgent()) 4888 composeReference(t, "DeviceRequest", "agent", element.getAgent(), -1); 4889 if (element.hasOnBehalfOf()) 4890 composeReference(t, "DeviceRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 4891 } 4892 4893 protected void composeDeviceUseStatement(Complex parent, String parentType, String name, DeviceUseStatement element, int index) { 4894 if (element == null) 4895 return; 4896 Complex t; 4897 if (Utilities.noString(parentType)) 4898 t = parent; 4899 else { 4900 t = parent.predicate("fhir:"+parentType+'.'+name); 4901 } 4902 composeDomainResource(t, "DeviceUseStatement", name, element, index); 4903 for (int i = 0; i < element.getIdentifier().size(); i++) 4904 composeIdentifier(t, "DeviceUseStatement", "identifier", element.getIdentifier().get(i), i); 4905 if (element.hasStatusElement()) 4906 composeEnum(t, "DeviceUseStatement", "status", element.getStatusElement(), -1); 4907 if (element.hasSubject()) 4908 composeReference(t, "DeviceUseStatement", "subject", element.getSubject(), -1); 4909 if (element.hasWhenUsed()) 4910 composePeriod(t, "DeviceUseStatement", "whenUsed", element.getWhenUsed(), -1); 4911 if (element.hasTiming()) 4912 composeType(t, "DeviceUseStatement", "timing", element.getTiming(), -1); 4913 if (element.hasRecordedOnElement()) 4914 composeDateTime(t, "DeviceUseStatement", "recordedOn", element.getRecordedOnElement(), -1); 4915 if (element.hasSource()) 4916 composeReference(t, "DeviceUseStatement", "source", element.getSource(), -1); 4917 if (element.hasDevice()) 4918 composeReference(t, "DeviceUseStatement", "device", element.getDevice(), -1); 4919 for (int i = 0; i < element.getIndication().size(); i++) 4920 composeCodeableConcept(t, "DeviceUseStatement", "indication", element.getIndication().get(i), i); 4921 if (element.hasBodySite()) 4922 composeCodeableConcept(t, "DeviceUseStatement", "bodySite", element.getBodySite(), -1); 4923 for (int i = 0; i < element.getNote().size(); i++) 4924 composeAnnotation(t, "DeviceUseStatement", "note", element.getNote().get(i), i); 4925 } 4926 4927 protected void composeDiagnosticReport(Complex parent, String parentType, String name, DiagnosticReport element, int index) { 4928 if (element == null) 4929 return; 4930 Complex t; 4931 if (Utilities.noString(parentType)) 4932 t = parent; 4933 else { 4934 t = parent.predicate("fhir:"+parentType+'.'+name); 4935 } 4936 composeDomainResource(t, "DiagnosticReport", name, element, index); 4937 for (int i = 0; i < element.getIdentifier().size(); i++) 4938 composeIdentifier(t, "DiagnosticReport", "identifier", element.getIdentifier().get(i), i); 4939 for (int i = 0; i < element.getBasedOn().size(); i++) 4940 composeReference(t, "DiagnosticReport", "basedOn", element.getBasedOn().get(i), i); 4941 if (element.hasStatusElement()) 4942 composeEnum(t, "DiagnosticReport", "status", element.getStatusElement(), -1); 4943 if (element.hasCategory()) 4944 composeCodeableConcept(t, "DiagnosticReport", "category", element.getCategory(), -1); 4945 if (element.hasCode()) 4946 composeCodeableConcept(t, "DiagnosticReport", "code", element.getCode(), -1); 4947 if (element.hasSubject()) 4948 composeReference(t, "DiagnosticReport", "subject", element.getSubject(), -1); 4949 if (element.hasContext()) 4950 composeReference(t, "DiagnosticReport", "context", element.getContext(), -1); 4951 if (element.hasEffective()) 4952 composeType(t, "DiagnosticReport", "effective", element.getEffective(), -1); 4953 if (element.hasIssuedElement()) 4954 composeInstant(t, "DiagnosticReport", "issued", element.getIssuedElement(), -1); 4955 for (int i = 0; i < element.getPerformer().size(); i++) 4956 composeDiagnosticReportDiagnosticReportPerformerComponent(t, "DiagnosticReport", "performer", element.getPerformer().get(i), i); 4957 for (int i = 0; i < element.getSpecimen().size(); i++) 4958 composeReference(t, "DiagnosticReport", "specimen", element.getSpecimen().get(i), i); 4959 for (int i = 0; i < element.getResult().size(); i++) 4960 composeReference(t, "DiagnosticReport", "result", element.getResult().get(i), i); 4961 for (int i = 0; i < element.getImagingStudy().size(); i++) 4962 composeReference(t, "DiagnosticReport", "imagingStudy", element.getImagingStudy().get(i), i); 4963 for (int i = 0; i < element.getImage().size(); i++) 4964 composeDiagnosticReportDiagnosticReportImageComponent(t, "DiagnosticReport", "image", element.getImage().get(i), i); 4965 if (element.hasConclusionElement()) 4966 composeString(t, "DiagnosticReport", "conclusion", element.getConclusionElement(), -1); 4967 for (int i = 0; i < element.getCodedDiagnosis().size(); i++) 4968 composeCodeableConcept(t, "DiagnosticReport", "codedDiagnosis", element.getCodedDiagnosis().get(i), i); 4969 for (int i = 0; i < element.getPresentedForm().size(); i++) 4970 composeAttachment(t, "DiagnosticReport", "presentedForm", element.getPresentedForm().get(i), i); 4971 } 4972 4973 protected void composeDiagnosticReportDiagnosticReportPerformerComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportPerformerComponent element, int index) { 4974 if (element == null) 4975 return; 4976 Complex t; 4977 if (Utilities.noString(parentType)) 4978 t = parent; 4979 else { 4980 t = parent.predicate("fhir:"+parentType+'.'+name); 4981 } 4982 composeBackboneElement(t, "performer", name, element, index); 4983 if (element.hasRole()) 4984 composeCodeableConcept(t, "DiagnosticReport", "role", element.getRole(), -1); 4985 if (element.hasActor()) 4986 composeReference(t, "DiagnosticReport", "actor", element.getActor(), -1); 4987 } 4988 4989 protected void composeDiagnosticReportDiagnosticReportImageComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportImageComponent element, int index) { 4990 if (element == null) 4991 return; 4992 Complex t; 4993 if (Utilities.noString(parentType)) 4994 t = parent; 4995 else { 4996 t = parent.predicate("fhir:"+parentType+'.'+name); 4997 } 4998 composeBackboneElement(t, "image", name, element, index); 4999 if (element.hasCommentElement()) 5000 composeString(t, "DiagnosticReport", "comment", element.getCommentElement(), -1); 5001 if (element.hasLink()) 5002 composeReference(t, "DiagnosticReport", "link", element.getLink(), -1); 5003 } 5004 5005 protected void composeDocumentManifest(Complex parent, String parentType, String name, DocumentManifest element, int index) { 5006 if (element == null) 5007 return; 5008 Complex t; 5009 if (Utilities.noString(parentType)) 5010 t = parent; 5011 else { 5012 t = parent.predicate("fhir:"+parentType+'.'+name); 5013 } 5014 composeDomainResource(t, "DocumentManifest", name, element, index); 5015 if (element.hasMasterIdentifier()) 5016 composeIdentifier(t, "DocumentManifest", "masterIdentifier", element.getMasterIdentifier(), -1); 5017 for (int i = 0; i < element.getIdentifier().size(); i++) 5018 composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier().get(i), i); 5019 if (element.hasStatusElement()) 5020 composeEnum(t, "DocumentManifest", "status", element.getStatusElement(), -1); 5021 if (element.hasType()) 5022 composeCodeableConcept(t, "DocumentManifest", "type", element.getType(), -1); 5023 if (element.hasSubject()) 5024 composeReference(t, "DocumentManifest", "subject", element.getSubject(), -1); 5025 if (element.hasCreatedElement()) 5026 composeDateTime(t, "DocumentManifest", "created", element.getCreatedElement(), -1); 5027 for (int i = 0; i < element.getAuthor().size(); i++) 5028 composeReference(t, "DocumentManifest", "author", element.getAuthor().get(i), i); 5029 for (int i = 0; i < element.getRecipient().size(); i++) 5030 composeReference(t, "DocumentManifest", "recipient", element.getRecipient().get(i), i); 5031 if (element.hasSourceElement()) 5032 composeUri(t, "DocumentManifest", "source", element.getSourceElement(), -1); 5033 if (element.hasDescriptionElement()) 5034 composeString(t, "DocumentManifest", "description", element.getDescriptionElement(), -1); 5035 for (int i = 0; i < element.getContent().size(); i++) 5036 composeDocumentManifestDocumentManifestContentComponent(t, "DocumentManifest", "content", element.getContent().get(i), i); 5037 for (int i = 0; i < element.getRelated().size(); i++) 5038 composeDocumentManifestDocumentManifestRelatedComponent(t, "DocumentManifest", "related", element.getRelated().get(i), i); 5039 } 5040 5041 protected void composeDocumentManifestDocumentManifestContentComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestContentComponent element, int index) { 5042 if (element == null) 5043 return; 5044 Complex t; 5045 if (Utilities.noString(parentType)) 5046 t = parent; 5047 else { 5048 t = parent.predicate("fhir:"+parentType+'.'+name); 5049 } 5050 composeBackboneElement(t, "content", name, element, index); 5051 if (element.hasP()) 5052 composeType(t, "DocumentManifest", "p", element.getP(), -1); 5053 } 5054 5055 protected void composeDocumentManifestDocumentManifestRelatedComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestRelatedComponent element, int index) { 5056 if (element == null) 5057 return; 5058 Complex t; 5059 if (Utilities.noString(parentType)) 5060 t = parent; 5061 else { 5062 t = parent.predicate("fhir:"+parentType+'.'+name); 5063 } 5064 composeBackboneElement(t, "related", name, element, index); 5065 if (element.hasIdentifier()) 5066 composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier(), -1); 5067 if (element.hasRef()) 5068 composeReference(t, "DocumentManifest", "ref", element.getRef(), -1); 5069 } 5070 5071 protected void composeDocumentReference(Complex parent, String parentType, String name, DocumentReference element, int index) { 5072 if (element == null) 5073 return; 5074 Complex t; 5075 if (Utilities.noString(parentType)) 5076 t = parent; 5077 else { 5078 t = parent.predicate("fhir:"+parentType+'.'+name); 5079 } 5080 composeDomainResource(t, "DocumentReference", name, element, index); 5081 if (element.hasMasterIdentifier()) 5082 composeIdentifier(t, "DocumentReference", "masterIdentifier", element.getMasterIdentifier(), -1); 5083 for (int i = 0; i < element.getIdentifier().size(); i++) 5084 composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier().get(i), i); 5085 if (element.hasStatusElement()) 5086 composeEnum(t, "DocumentReference", "status", element.getStatusElement(), -1); 5087 if (element.hasDocStatusElement()) 5088 composeEnum(t, "DocumentReference", "docStatus", element.getDocStatusElement(), -1); 5089 if (element.hasType()) 5090 composeCodeableConcept(t, "DocumentReference", "type", element.getType(), -1); 5091 if (element.hasClass_()) 5092 composeCodeableConcept(t, "DocumentReference", "class", element.getClass_(), -1); 5093 if (element.hasSubject()) 5094 composeReference(t, "DocumentReference", "subject", element.getSubject(), -1); 5095 if (element.hasCreatedElement()) 5096 composeDateTime(t, "DocumentReference", "created", element.getCreatedElement(), -1); 5097 if (element.hasIndexedElement()) 5098 composeInstant(t, "DocumentReference", "indexed", element.getIndexedElement(), -1); 5099 for (int i = 0; i < element.getAuthor().size(); i++) 5100 composeReference(t, "DocumentReference", "author", element.getAuthor().get(i), i); 5101 if (element.hasAuthenticator()) 5102 composeReference(t, "DocumentReference", "authenticator", element.getAuthenticator(), -1); 5103 if (element.hasCustodian()) 5104 composeReference(t, "DocumentReference", "custodian", element.getCustodian(), -1); 5105 for (int i = 0; i < element.getRelatesTo().size(); i++) 5106 composeDocumentReferenceDocumentReferenceRelatesToComponent(t, "DocumentReference", "relatesTo", element.getRelatesTo().get(i), i); 5107 if (element.hasDescriptionElement()) 5108 composeString(t, "DocumentReference", "description", element.getDescriptionElement(), -1); 5109 for (int i = 0; i < element.getSecurityLabel().size(); i++) 5110 composeCodeableConcept(t, "DocumentReference", "securityLabel", element.getSecurityLabel().get(i), i); 5111 for (int i = 0; i < element.getContent().size(); i++) 5112 composeDocumentReferenceDocumentReferenceContentComponent(t, "DocumentReference", "content", element.getContent().get(i), i); 5113 if (element.hasContext()) 5114 composeDocumentReferenceDocumentReferenceContextComponent(t, "DocumentReference", "context", element.getContext(), -1); 5115 } 5116 5117 protected void composeDocumentReferenceDocumentReferenceRelatesToComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceRelatesToComponent element, int index) { 5118 if (element == null) 5119 return; 5120 Complex t; 5121 if (Utilities.noString(parentType)) 5122 t = parent; 5123 else { 5124 t = parent.predicate("fhir:"+parentType+'.'+name); 5125 } 5126 composeBackboneElement(t, "relatesTo", name, element, index); 5127 if (element.hasCodeElement()) 5128 composeEnum(t, "DocumentReference", "code", element.getCodeElement(), -1); 5129 if (element.hasTarget()) 5130 composeReference(t, "DocumentReference", "target", element.getTarget(), -1); 5131 } 5132 5133 protected void composeDocumentReferenceDocumentReferenceContentComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContentComponent element, int index) { 5134 if (element == null) 5135 return; 5136 Complex t; 5137 if (Utilities.noString(parentType)) 5138 t = parent; 5139 else { 5140 t = parent.predicate("fhir:"+parentType+'.'+name); 5141 } 5142 composeBackboneElement(t, "content", name, element, index); 5143 if (element.hasAttachment()) 5144 composeAttachment(t, "DocumentReference", "attachment", element.getAttachment(), -1); 5145 if (element.hasFormat()) 5146 composeCoding(t, "DocumentReference", "format", element.getFormat(), -1); 5147 } 5148 5149 protected void composeDocumentReferenceDocumentReferenceContextComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextComponent element, int index) { 5150 if (element == null) 5151 return; 5152 Complex t; 5153 if (Utilities.noString(parentType)) 5154 t = parent; 5155 else { 5156 t = parent.predicate("fhir:"+parentType+'.'+name); 5157 } 5158 composeBackboneElement(t, "context", name, element, index); 5159 if (element.hasEncounter()) 5160 composeReference(t, "DocumentReference", "encounter", element.getEncounter(), -1); 5161 for (int i = 0; i < element.getEvent().size(); i++) 5162 composeCodeableConcept(t, "DocumentReference", "event", element.getEvent().get(i), i); 5163 if (element.hasPeriod()) 5164 composePeriod(t, "DocumentReference", "period", element.getPeriod(), -1); 5165 if (element.hasFacilityType()) 5166 composeCodeableConcept(t, "DocumentReference", "facilityType", element.getFacilityType(), -1); 5167 if (element.hasPracticeSetting()) 5168 composeCodeableConcept(t, "DocumentReference", "practiceSetting", element.getPracticeSetting(), -1); 5169 if (element.hasSourcePatientInfo()) 5170 composeReference(t, "DocumentReference", "sourcePatientInfo", element.getSourcePatientInfo(), -1); 5171 for (int i = 0; i < element.getRelated().size(); i++) 5172 composeDocumentReferenceDocumentReferenceContextRelatedComponent(t, "DocumentReference", "related", element.getRelated().get(i), i); 5173 } 5174 5175 protected void composeDocumentReferenceDocumentReferenceContextRelatedComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextRelatedComponent element, int index) { 5176 if (element == null) 5177 return; 5178 Complex t; 5179 if (Utilities.noString(parentType)) 5180 t = parent; 5181 else { 5182 t = parent.predicate("fhir:"+parentType+'.'+name); 5183 } 5184 composeBackboneElement(t, "related", name, element, index); 5185 if (element.hasIdentifier()) 5186 composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier(), -1); 5187 if (element.hasRef()) 5188 composeReference(t, "DocumentReference", "ref", element.getRef(), -1); 5189 } 5190 5191 protected void composeEligibilityRequest(Complex parent, String parentType, String name, EligibilityRequest element, int index) { 5192 if (element == null) 5193 return; 5194 Complex t; 5195 if (Utilities.noString(parentType)) 5196 t = parent; 5197 else { 5198 t = parent.predicate("fhir:"+parentType+'.'+name); 5199 } 5200 composeDomainResource(t, "EligibilityRequest", name, element, index); 5201 for (int i = 0; i < element.getIdentifier().size(); i++) 5202 composeIdentifier(t, "EligibilityRequest", "identifier", element.getIdentifier().get(i), i); 5203 if (element.hasStatusElement()) 5204 composeEnum(t, "EligibilityRequest", "status", element.getStatusElement(), -1); 5205 if (element.hasPriority()) 5206 composeCodeableConcept(t, "EligibilityRequest", "priority", element.getPriority(), -1); 5207 if (element.hasPatient()) 5208 composeReference(t, "EligibilityRequest", "patient", element.getPatient(), -1); 5209 if (element.hasServiced()) 5210 composeType(t, "EligibilityRequest", "serviced", element.getServiced(), -1); 5211 if (element.hasCreatedElement()) 5212 composeDateTime(t, "EligibilityRequest", "created", element.getCreatedElement(), -1); 5213 if (element.hasEnterer()) 5214 composeReference(t, "EligibilityRequest", "enterer", element.getEnterer(), -1); 5215 if (element.hasProvider()) 5216 composeReference(t, "EligibilityRequest", "provider", element.getProvider(), -1); 5217 if (element.hasOrganization()) 5218 composeReference(t, "EligibilityRequest", "organization", element.getOrganization(), -1); 5219 if (element.hasInsurer()) 5220 composeReference(t, "EligibilityRequest", "insurer", element.getInsurer(), -1); 5221 if (element.hasFacility()) 5222 composeReference(t, "EligibilityRequest", "facility", element.getFacility(), -1); 5223 if (element.hasCoverage()) 5224 composeReference(t, "EligibilityRequest", "coverage", element.getCoverage(), -1); 5225 if (element.hasBusinessArrangementElement()) 5226 composeString(t, "EligibilityRequest", "businessArrangement", element.getBusinessArrangementElement(), -1); 5227 if (element.hasBenefitCategory()) 5228 composeCodeableConcept(t, "EligibilityRequest", "benefitCategory", element.getBenefitCategory(), -1); 5229 if (element.hasBenefitSubCategory()) 5230 composeCodeableConcept(t, "EligibilityRequest", "benefitSubCategory", element.getBenefitSubCategory(), -1); 5231 } 5232 5233 protected void composeEligibilityResponse(Complex parent, String parentType, String name, EligibilityResponse element, int index) { 5234 if (element == null) 5235 return; 5236 Complex t; 5237 if (Utilities.noString(parentType)) 5238 t = parent; 5239 else { 5240 t = parent.predicate("fhir:"+parentType+'.'+name); 5241 } 5242 composeDomainResource(t, "EligibilityResponse", name, element, index); 5243 for (int i = 0; i < element.getIdentifier().size(); i++) 5244 composeIdentifier(t, "EligibilityResponse", "identifier", element.getIdentifier().get(i), i); 5245 if (element.hasStatusElement()) 5246 composeEnum(t, "EligibilityResponse", "status", element.getStatusElement(), -1); 5247 if (element.hasCreatedElement()) 5248 composeDateTime(t, "EligibilityResponse", "created", element.getCreatedElement(), -1); 5249 if (element.hasRequestProvider()) 5250 composeReference(t, "EligibilityResponse", "requestProvider", element.getRequestProvider(), -1); 5251 if (element.hasRequestOrganization()) 5252 composeReference(t, "EligibilityResponse", "requestOrganization", element.getRequestOrganization(), -1); 5253 if (element.hasRequest()) 5254 composeReference(t, "EligibilityResponse", "request", element.getRequest(), -1); 5255 if (element.hasOutcome()) 5256 composeCodeableConcept(t, "EligibilityResponse", "outcome", element.getOutcome(), -1); 5257 if (element.hasDispositionElement()) 5258 composeString(t, "EligibilityResponse", "disposition", element.getDispositionElement(), -1); 5259 if (element.hasInsurer()) 5260 composeReference(t, "EligibilityResponse", "insurer", element.getInsurer(), -1); 5261 if (element.hasInforceElement()) 5262 composeBoolean(t, "EligibilityResponse", "inforce", element.getInforceElement(), -1); 5263 for (int i = 0; i < element.getInsurance().size(); i++) 5264 composeEligibilityResponseInsuranceComponent(t, "EligibilityResponse", "insurance", element.getInsurance().get(i), i); 5265 if (element.hasForm()) 5266 composeCodeableConcept(t, "EligibilityResponse", "form", element.getForm(), -1); 5267 for (int i = 0; i < element.getError().size(); i++) 5268 composeEligibilityResponseErrorsComponent(t, "EligibilityResponse", "error", element.getError().get(i), i); 5269 } 5270 5271 protected void composeEligibilityResponseInsuranceComponent(Complex parent, String parentType, String name, EligibilityResponse.InsuranceComponent element, int index) { 5272 if (element == null) 5273 return; 5274 Complex t; 5275 if (Utilities.noString(parentType)) 5276 t = parent; 5277 else { 5278 t = parent.predicate("fhir:"+parentType+'.'+name); 5279 } 5280 composeBackboneElement(t, "insurance", name, element, index); 5281 if (element.hasCoverage()) 5282 composeReference(t, "EligibilityResponse", "coverage", element.getCoverage(), -1); 5283 if (element.hasContract()) 5284 composeReference(t, "EligibilityResponse", "contract", element.getContract(), -1); 5285 for (int i = 0; i < element.getBenefitBalance().size(); i++) 5286 composeEligibilityResponseBenefitsComponent(t, "EligibilityResponse", "benefitBalance", element.getBenefitBalance().get(i), i); 5287 } 5288 5289 protected void composeEligibilityResponseBenefitsComponent(Complex parent, String parentType, String name, EligibilityResponse.BenefitsComponent element, int index) { 5290 if (element == null) 5291 return; 5292 Complex t; 5293 if (Utilities.noString(parentType)) 5294 t = parent; 5295 else { 5296 t = parent.predicate("fhir:"+parentType+'.'+name); 5297 } 5298 composeBackboneElement(t, "benefitBalance", name, element, index); 5299 if (element.hasCategory()) 5300 composeCodeableConcept(t, "EligibilityResponse", "category", element.getCategory(), -1); 5301 if (element.hasSubCategory()) 5302 composeCodeableConcept(t, "EligibilityResponse", "subCategory", element.getSubCategory(), -1); 5303 if (element.hasExcludedElement()) 5304 composeBoolean(t, "EligibilityResponse", "excluded", element.getExcludedElement(), -1); 5305 if (element.hasNameElement()) 5306 composeString(t, "EligibilityResponse", "name", element.getNameElement(), -1); 5307 if (element.hasDescriptionElement()) 5308 composeString(t, "EligibilityResponse", "description", element.getDescriptionElement(), -1); 5309 if (element.hasNetwork()) 5310 composeCodeableConcept(t, "EligibilityResponse", "network", element.getNetwork(), -1); 5311 if (element.hasUnit()) 5312 composeCodeableConcept(t, "EligibilityResponse", "unit", element.getUnit(), -1); 5313 if (element.hasTerm()) 5314 composeCodeableConcept(t, "EligibilityResponse", "term", element.getTerm(), -1); 5315 for (int i = 0; i < element.getFinancial().size(); i++) 5316 composeEligibilityResponseBenefitComponent(t, "EligibilityResponse", "financial", element.getFinancial().get(i), i); 5317 } 5318 5319 protected void composeEligibilityResponseBenefitComponent(Complex parent, String parentType, String name, EligibilityResponse.BenefitComponent element, int index) { 5320 if (element == null) 5321 return; 5322 Complex t; 5323 if (Utilities.noString(parentType)) 5324 t = parent; 5325 else { 5326 t = parent.predicate("fhir:"+parentType+'.'+name); 5327 } 5328 composeBackboneElement(t, "financial", name, element, index); 5329 if (element.hasType()) 5330 composeCodeableConcept(t, "EligibilityResponse", "type", element.getType(), -1); 5331 if (element.hasAllowed()) 5332 composeType(t, "EligibilityResponse", "allowed", element.getAllowed(), -1); 5333 if (element.hasUsed()) 5334 composeType(t, "EligibilityResponse", "used", element.getUsed(), -1); 5335 } 5336 5337 protected void composeEligibilityResponseErrorsComponent(Complex parent, String parentType, String name, EligibilityResponse.ErrorsComponent element, int index) { 5338 if (element == null) 5339 return; 5340 Complex t; 5341 if (Utilities.noString(parentType)) 5342 t = parent; 5343 else { 5344 t = parent.predicate("fhir:"+parentType+'.'+name); 5345 } 5346 composeBackboneElement(t, "error", name, element, index); 5347 if (element.hasCode()) 5348 composeCodeableConcept(t, "EligibilityResponse", "code", element.getCode(), -1); 5349 } 5350 5351 protected void composeEncounter(Complex parent, String parentType, String name, Encounter element, int index) { 5352 if (element == null) 5353 return; 5354 Complex t; 5355 if (Utilities.noString(parentType)) 5356 t = parent; 5357 else { 5358 t = parent.predicate("fhir:"+parentType+'.'+name); 5359 } 5360 composeDomainResource(t, "Encounter", name, element, index); 5361 for (int i = 0; i < element.getIdentifier().size(); i++) 5362 composeIdentifier(t, "Encounter", "identifier", element.getIdentifier().get(i), i); 5363 if (element.hasStatusElement()) 5364 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 5365 for (int i = 0; i < element.getStatusHistory().size(); i++) 5366 composeEncounterStatusHistoryComponent(t, "Encounter", "statusHistory", element.getStatusHistory().get(i), i); 5367 if (element.hasClass_()) 5368 composeCoding(t, "Encounter", "class", element.getClass_(), -1); 5369 for (int i = 0; i < element.getClassHistory().size(); i++) 5370 composeEncounterClassHistoryComponent(t, "Encounter", "classHistory", element.getClassHistory().get(i), i); 5371 for (int i = 0; i < element.getType().size(); i++) 5372 composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i); 5373 if (element.hasPriority()) 5374 composeCodeableConcept(t, "Encounter", "priority", element.getPriority(), -1); 5375 if (element.hasSubject()) 5376 composeReference(t, "Encounter", "subject", element.getSubject(), -1); 5377 for (int i = 0; i < element.getEpisodeOfCare().size(); i++) 5378 composeReference(t, "Encounter", "episodeOfCare", element.getEpisodeOfCare().get(i), i); 5379 for (int i = 0; i < element.getIncomingReferral().size(); i++) 5380 composeReference(t, "Encounter", "incomingReferral", element.getIncomingReferral().get(i), i); 5381 for (int i = 0; i < element.getParticipant().size(); i++) 5382 composeEncounterEncounterParticipantComponent(t, "Encounter", "participant", element.getParticipant().get(i), i); 5383 if (element.hasAppointment()) 5384 composeReference(t, "Encounter", "appointment", element.getAppointment(), -1); 5385 if (element.hasPeriod()) 5386 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5387 if (element.hasLength()) 5388 composeDuration(t, "Encounter", "length", element.getLength(), -1); 5389 for (int i = 0; i < element.getReason().size(); i++) 5390 composeCodeableConcept(t, "Encounter", "reason", element.getReason().get(i), i); 5391 for (int i = 0; i < element.getDiagnosis().size(); i++) 5392 composeEncounterDiagnosisComponent(t, "Encounter", "diagnosis", element.getDiagnosis().get(i), i); 5393 for (int i = 0; i < element.getAccount().size(); i++) 5394 composeReference(t, "Encounter", "account", element.getAccount().get(i), i); 5395 if (element.hasHospitalization()) 5396 composeEncounterEncounterHospitalizationComponent(t, "Encounter", "hospitalization", element.getHospitalization(), -1); 5397 for (int i = 0; i < element.getLocation().size(); i++) 5398 composeEncounterEncounterLocationComponent(t, "Encounter", "location", element.getLocation().get(i), i); 5399 if (element.hasServiceProvider()) 5400 composeReference(t, "Encounter", "serviceProvider", element.getServiceProvider(), -1); 5401 if (element.hasPartOf()) 5402 composeReference(t, "Encounter", "partOf", element.getPartOf(), -1); 5403 } 5404 5405 protected void composeEncounterStatusHistoryComponent(Complex parent, String parentType, String name, Encounter.StatusHistoryComponent element, int index) { 5406 if (element == null) 5407 return; 5408 Complex t; 5409 if (Utilities.noString(parentType)) 5410 t = parent; 5411 else { 5412 t = parent.predicate("fhir:"+parentType+'.'+name); 5413 } 5414 composeBackboneElement(t, "statusHistory", name, element, index); 5415 if (element.hasStatusElement()) 5416 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 5417 if (element.hasPeriod()) 5418 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5419 } 5420 5421 protected void composeEncounterClassHistoryComponent(Complex parent, String parentType, String name, Encounter.ClassHistoryComponent element, int index) { 5422 if (element == null) 5423 return; 5424 Complex t; 5425 if (Utilities.noString(parentType)) 5426 t = parent; 5427 else { 5428 t = parent.predicate("fhir:"+parentType+'.'+name); 5429 } 5430 composeBackboneElement(t, "classHistory", name, element, index); 5431 if (element.hasClass_()) 5432 composeCoding(t, "Encounter", "class", element.getClass_(), -1); 5433 if (element.hasPeriod()) 5434 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5435 } 5436 5437 protected void composeEncounterEncounterParticipantComponent(Complex parent, String parentType, String name, Encounter.EncounterParticipantComponent element, int index) { 5438 if (element == null) 5439 return; 5440 Complex t; 5441 if (Utilities.noString(parentType)) 5442 t = parent; 5443 else { 5444 t = parent.predicate("fhir:"+parentType+'.'+name); 5445 } 5446 composeBackboneElement(t, "participant", name, element, index); 5447 for (int i = 0; i < element.getType().size(); i++) 5448 composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i); 5449 if (element.hasPeriod()) 5450 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5451 if (element.hasIndividual()) 5452 composeReference(t, "Encounter", "individual", element.getIndividual(), -1); 5453 } 5454 5455 protected void composeEncounterDiagnosisComponent(Complex parent, String parentType, String name, Encounter.DiagnosisComponent element, int index) { 5456 if (element == null) 5457 return; 5458 Complex t; 5459 if (Utilities.noString(parentType)) 5460 t = parent; 5461 else { 5462 t = parent.predicate("fhir:"+parentType+'.'+name); 5463 } 5464 composeBackboneElement(t, "diagnosis", name, element, index); 5465 if (element.hasCondition()) 5466 composeReference(t, "Encounter", "condition", element.getCondition(), -1); 5467 if (element.hasRole()) 5468 composeCodeableConcept(t, "Encounter", "role", element.getRole(), -1); 5469 if (element.hasRankElement()) 5470 composePositiveInt(t, "Encounter", "rank", element.getRankElement(), -1); 5471 } 5472 5473 protected void composeEncounterEncounterHospitalizationComponent(Complex parent, String parentType, String name, Encounter.EncounterHospitalizationComponent element, int index) { 5474 if (element == null) 5475 return; 5476 Complex t; 5477 if (Utilities.noString(parentType)) 5478 t = parent; 5479 else { 5480 t = parent.predicate("fhir:"+parentType+'.'+name); 5481 } 5482 composeBackboneElement(t, "hospitalization", name, element, index); 5483 if (element.hasPreAdmissionIdentifier()) 5484 composeIdentifier(t, "Encounter", "preAdmissionIdentifier", element.getPreAdmissionIdentifier(), -1); 5485 if (element.hasOrigin()) 5486 composeReference(t, "Encounter", "origin", element.getOrigin(), -1); 5487 if (element.hasAdmitSource()) 5488 composeCodeableConcept(t, "Encounter", "admitSource", element.getAdmitSource(), -1); 5489 if (element.hasReAdmission()) 5490 composeCodeableConcept(t, "Encounter", "reAdmission", element.getReAdmission(), -1); 5491 for (int i = 0; i < element.getDietPreference().size(); i++) 5492 composeCodeableConcept(t, "Encounter", "dietPreference", element.getDietPreference().get(i), i); 5493 for (int i = 0; i < element.getSpecialCourtesy().size(); i++) 5494 composeCodeableConcept(t, "Encounter", "specialCourtesy", element.getSpecialCourtesy().get(i), i); 5495 for (int i = 0; i < element.getSpecialArrangement().size(); i++) 5496 composeCodeableConcept(t, "Encounter", "specialArrangement", element.getSpecialArrangement().get(i), i); 5497 if (element.hasDestination()) 5498 composeReference(t, "Encounter", "destination", element.getDestination(), -1); 5499 if (element.hasDischargeDisposition()) 5500 composeCodeableConcept(t, "Encounter", "dischargeDisposition", element.getDischargeDisposition(), -1); 5501 } 5502 5503 protected void composeEncounterEncounterLocationComponent(Complex parent, String parentType, String name, Encounter.EncounterLocationComponent element, int index) { 5504 if (element == null) 5505 return; 5506 Complex t; 5507 if (Utilities.noString(parentType)) 5508 t = parent; 5509 else { 5510 t = parent.predicate("fhir:"+parentType+'.'+name); 5511 } 5512 composeBackboneElement(t, "location", name, element, index); 5513 if (element.hasLocation()) 5514 composeReference(t, "Encounter", "location", element.getLocation(), -1); 5515 if (element.hasStatusElement()) 5516 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 5517 if (element.hasPeriod()) 5518 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 5519 } 5520 5521 protected void composeEndpoint(Complex parent, String parentType, String name, Endpoint element, int index) { 5522 if (element == null) 5523 return; 5524 Complex t; 5525 if (Utilities.noString(parentType)) 5526 t = parent; 5527 else { 5528 t = parent.predicate("fhir:"+parentType+'.'+name); 5529 } 5530 composeDomainResource(t, "Endpoint", name, element, index); 5531 for (int i = 0; i < element.getIdentifier().size(); i++) 5532 composeIdentifier(t, "Endpoint", "identifier", element.getIdentifier().get(i), i); 5533 if (element.hasStatusElement()) 5534 composeEnum(t, "Endpoint", "status", element.getStatusElement(), -1); 5535 if (element.hasConnectionType()) 5536 composeCoding(t, "Endpoint", "connectionType", element.getConnectionType(), -1); 5537 if (element.hasNameElement()) 5538 composeString(t, "Endpoint", "name", element.getNameElement(), -1); 5539 if (element.hasManagingOrganization()) 5540 composeReference(t, "Endpoint", "managingOrganization", element.getManagingOrganization(), -1); 5541 for (int i = 0; i < element.getContact().size(); i++) 5542 composeContactPoint(t, "Endpoint", "contact", element.getContact().get(i), i); 5543 if (element.hasPeriod()) 5544 composePeriod(t, "Endpoint", "period", element.getPeriod(), -1); 5545 for (int i = 0; i < element.getPayloadType().size(); i++) 5546 composeCodeableConcept(t, "Endpoint", "payloadType", element.getPayloadType().get(i), i); 5547 for (int i = 0; i < element.getPayloadMimeType().size(); i++) 5548 composeCode(t, "Endpoint", "payloadMimeType", element.getPayloadMimeType().get(i), i); 5549 if (element.hasAddressElement()) 5550 composeUri(t, "Endpoint", "address", element.getAddressElement(), -1); 5551 for (int i = 0; i < element.getHeader().size(); i++) 5552 composeString(t, "Endpoint", "header", element.getHeader().get(i), i); 5553 } 5554 5555 protected void composeEnrollmentRequest(Complex parent, String parentType, String name, EnrollmentRequest element, int index) { 5556 if (element == null) 5557 return; 5558 Complex t; 5559 if (Utilities.noString(parentType)) 5560 t = parent; 5561 else { 5562 t = parent.predicate("fhir:"+parentType+'.'+name); 5563 } 5564 composeDomainResource(t, "EnrollmentRequest", name, element, index); 5565 for (int i = 0; i < element.getIdentifier().size(); i++) 5566 composeIdentifier(t, "EnrollmentRequest", "identifier", element.getIdentifier().get(i), i); 5567 if (element.hasStatusElement()) 5568 composeEnum(t, "EnrollmentRequest", "status", element.getStatusElement(), -1); 5569 if (element.hasCreatedElement()) 5570 composeDateTime(t, "EnrollmentRequest", "created", element.getCreatedElement(), -1); 5571 if (element.hasInsurer()) 5572 composeReference(t, "EnrollmentRequest", "insurer", element.getInsurer(), -1); 5573 if (element.hasProvider()) 5574 composeReference(t, "EnrollmentRequest", "provider", element.getProvider(), -1); 5575 if (element.hasOrganization()) 5576 composeReference(t, "EnrollmentRequest", "organization", element.getOrganization(), -1); 5577 if (element.hasSubject()) 5578 composeReference(t, "EnrollmentRequest", "subject", element.getSubject(), -1); 5579 if (element.hasCoverage()) 5580 composeReference(t, "EnrollmentRequest", "coverage", element.getCoverage(), -1); 5581 } 5582 5583 protected void composeEnrollmentResponse(Complex parent, String parentType, String name, EnrollmentResponse element, int index) { 5584 if (element == null) 5585 return; 5586 Complex t; 5587 if (Utilities.noString(parentType)) 5588 t = parent; 5589 else { 5590 t = parent.predicate("fhir:"+parentType+'.'+name); 5591 } 5592 composeDomainResource(t, "EnrollmentResponse", name, element, index); 5593 for (int i = 0; i < element.getIdentifier().size(); i++) 5594 composeIdentifier(t, "EnrollmentResponse", "identifier", element.getIdentifier().get(i), i); 5595 if (element.hasStatusElement()) 5596 composeEnum(t, "EnrollmentResponse", "status", element.getStatusElement(), -1); 5597 if (element.hasRequest()) 5598 composeReference(t, "EnrollmentResponse", "request", element.getRequest(), -1); 5599 if (element.hasOutcome()) 5600 composeCodeableConcept(t, "EnrollmentResponse", "outcome", element.getOutcome(), -1); 5601 if (element.hasDispositionElement()) 5602 composeString(t, "EnrollmentResponse", "disposition", element.getDispositionElement(), -1); 5603 if (element.hasCreatedElement()) 5604 composeDateTime(t, "EnrollmentResponse", "created", element.getCreatedElement(), -1); 5605 if (element.hasOrganization()) 5606 composeReference(t, "EnrollmentResponse", "organization", element.getOrganization(), -1); 5607 if (element.hasRequestProvider()) 5608 composeReference(t, "EnrollmentResponse", "requestProvider", element.getRequestProvider(), -1); 5609 if (element.hasRequestOrganization()) 5610 composeReference(t, "EnrollmentResponse", "requestOrganization", element.getRequestOrganization(), -1); 5611 } 5612 5613 protected void composeEpisodeOfCare(Complex parent, String parentType, String name, EpisodeOfCare element, int index) { 5614 if (element == null) 5615 return; 5616 Complex t; 5617 if (Utilities.noString(parentType)) 5618 t = parent; 5619 else { 5620 t = parent.predicate("fhir:"+parentType+'.'+name); 5621 } 5622 composeDomainResource(t, "EpisodeOfCare", name, element, index); 5623 for (int i = 0; i < element.getIdentifier().size(); i++) 5624 composeIdentifier(t, "EpisodeOfCare", "identifier", element.getIdentifier().get(i), i); 5625 if (element.hasStatusElement()) 5626 composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1); 5627 for (int i = 0; i < element.getStatusHistory().size(); i++) 5628 composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(t, "EpisodeOfCare", "statusHistory", element.getStatusHistory().get(i), i); 5629 for (int i = 0; i < element.getType().size(); i++) 5630 composeCodeableConcept(t, "EpisodeOfCare", "type", element.getType().get(i), i); 5631 for (int i = 0; i < element.getDiagnosis().size(); i++) 5632 composeEpisodeOfCareDiagnosisComponent(t, "EpisodeOfCare", "diagnosis", element.getDiagnosis().get(i), i); 5633 if (element.hasPatient()) 5634 composeReference(t, "EpisodeOfCare", "patient", element.getPatient(), -1); 5635 if (element.hasManagingOrganization()) 5636 composeReference(t, "EpisodeOfCare", "managingOrganization", element.getManagingOrganization(), -1); 5637 if (element.hasPeriod()) 5638 composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1); 5639 for (int i = 0; i < element.getReferralRequest().size(); i++) 5640 composeReference(t, "EpisodeOfCare", "referralRequest", element.getReferralRequest().get(i), i); 5641 if (element.hasCareManager()) 5642 composeReference(t, "EpisodeOfCare", "careManager", element.getCareManager(), -1); 5643 for (int i = 0; i < element.getTeam().size(); i++) 5644 composeReference(t, "EpisodeOfCare", "team", element.getTeam().get(i), i); 5645 for (int i = 0; i < element.getAccount().size(); i++) 5646 composeReference(t, "EpisodeOfCare", "account", element.getAccount().get(i), i); 5647 } 5648 5649 protected void composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(Complex parent, String parentType, String name, EpisodeOfCare.EpisodeOfCareStatusHistoryComponent element, int index) { 5650 if (element == null) 5651 return; 5652 Complex t; 5653 if (Utilities.noString(parentType)) 5654 t = parent; 5655 else { 5656 t = parent.predicate("fhir:"+parentType+'.'+name); 5657 } 5658 composeBackboneElement(t, "statusHistory", name, element, index); 5659 if (element.hasStatusElement()) 5660 composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1); 5661 if (element.hasPeriod()) 5662 composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1); 5663 } 5664 5665 protected void composeEpisodeOfCareDiagnosisComponent(Complex parent, String parentType, String name, EpisodeOfCare.DiagnosisComponent element, int index) { 5666 if (element == null) 5667 return; 5668 Complex t; 5669 if (Utilities.noString(parentType)) 5670 t = parent; 5671 else { 5672 t = parent.predicate("fhir:"+parentType+'.'+name); 5673 } 5674 composeBackboneElement(t, "diagnosis", name, element, index); 5675 if (element.hasCondition()) 5676 composeReference(t, "EpisodeOfCare", "condition", element.getCondition(), -1); 5677 if (element.hasRole()) 5678 composeCodeableConcept(t, "EpisodeOfCare", "role", element.getRole(), -1); 5679 if (element.hasRankElement()) 5680 composePositiveInt(t, "EpisodeOfCare", "rank", element.getRankElement(), -1); 5681 } 5682 5683 protected void composeExpansionProfile(Complex parent, String parentType, String name, ExpansionProfile element, int index) { 5684 if (element == null) 5685 return; 5686 Complex t; 5687 if (Utilities.noString(parentType)) 5688 t = parent; 5689 else { 5690 t = parent.predicate("fhir:"+parentType+'.'+name); 5691 } 5692 composeDomainResource(t, "ExpansionProfile", name, element, index); 5693 if (element.hasUrlElement()) 5694 composeUri(t, "ExpansionProfile", "url", element.getUrlElement(), -1); 5695 if (element.hasIdentifier()) 5696 composeIdentifier(t, "ExpansionProfile", "identifier", element.getIdentifier(), -1); 5697 if (element.hasVersionElement()) 5698 composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1); 5699 if (element.hasNameElement()) 5700 composeString(t, "ExpansionProfile", "name", element.getNameElement(), -1); 5701 if (element.hasStatusElement()) 5702 composeEnum(t, "ExpansionProfile", "status", element.getStatusElement(), -1); 5703 if (element.hasExperimentalElement()) 5704 composeBoolean(t, "ExpansionProfile", "experimental", element.getExperimentalElement(), -1); 5705 if (element.hasDateElement()) 5706 composeDateTime(t, "ExpansionProfile", "date", element.getDateElement(), -1); 5707 if (element.hasPublisherElement()) 5708 composeString(t, "ExpansionProfile", "publisher", element.getPublisherElement(), -1); 5709 for (int i = 0; i < element.getContact().size(); i++) 5710 composeContactDetail(t, "ExpansionProfile", "contact", element.getContact().get(i), i); 5711 if (element.hasDescriptionElement()) 5712 composeMarkdown(t, "ExpansionProfile", "description", element.getDescriptionElement(), -1); 5713 for (int i = 0; i < element.getUseContext().size(); i++) 5714 composeUsageContext(t, "ExpansionProfile", "useContext", element.getUseContext().get(i), i); 5715 for (int i = 0; i < element.getJurisdiction().size(); i++) 5716 composeCodeableConcept(t, "ExpansionProfile", "jurisdiction", element.getJurisdiction().get(i), i); 5717 for (int i = 0; i < element.getFixedVersion().size(); i++) 5718 composeExpansionProfileExpansionProfileFixedVersionComponent(t, "ExpansionProfile", "fixedVersion", element.getFixedVersion().get(i), i); 5719 if (element.hasExcludedSystem()) 5720 composeExpansionProfileExpansionProfileExcludedSystemComponent(t, "ExpansionProfile", "excludedSystem", element.getExcludedSystem(), -1); 5721 if (element.hasIncludeDesignationsElement()) 5722 composeBoolean(t, "ExpansionProfile", "includeDesignations", element.getIncludeDesignationsElement(), -1); 5723 if (element.hasDesignation()) 5724 composeExpansionProfileExpansionProfileDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation(), -1); 5725 if (element.hasIncludeDefinitionElement()) 5726 composeBoolean(t, "ExpansionProfile", "includeDefinition", element.getIncludeDefinitionElement(), -1); 5727 if (element.hasActiveOnlyElement()) 5728 composeBoolean(t, "ExpansionProfile", "activeOnly", element.getActiveOnlyElement(), -1); 5729 if (element.hasExcludeNestedElement()) 5730 composeBoolean(t, "ExpansionProfile", "excludeNested", element.getExcludeNestedElement(), -1); 5731 if (element.hasExcludeNotForUIElement()) 5732 composeBoolean(t, "ExpansionProfile", "excludeNotForUI", element.getExcludeNotForUIElement(), -1); 5733 if (element.hasExcludePostCoordinatedElement()) 5734 composeBoolean(t, "ExpansionProfile", "excludePostCoordinated", element.getExcludePostCoordinatedElement(), -1); 5735 if (element.hasDisplayLanguageElement()) 5736 composeCode(t, "ExpansionProfile", "displayLanguage", element.getDisplayLanguageElement(), -1); 5737 if (element.hasLimitedExpansionElement()) 5738 composeBoolean(t, "ExpansionProfile", "limitedExpansion", element.getLimitedExpansionElement(), -1); 5739 } 5740 5741 protected void composeExpansionProfileExpansionProfileFixedVersionComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileFixedVersionComponent element, int index) { 5742 if (element == null) 5743 return; 5744 Complex t; 5745 if (Utilities.noString(parentType)) 5746 t = parent; 5747 else { 5748 t = parent.predicate("fhir:"+parentType+'.'+name); 5749 } 5750 composeBackboneElement(t, "fixedVersion", name, element, index); 5751 if (element.hasSystemElement()) 5752 composeUri(t, "ExpansionProfile", "system", element.getSystemElement(), -1); 5753 if (element.hasVersionElement()) 5754 composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1); 5755 if (element.hasModeElement()) 5756 composeEnum(t, "ExpansionProfile", "mode", element.getModeElement(), -1); 5757 } 5758 5759 protected void composeExpansionProfileExpansionProfileExcludedSystemComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileExcludedSystemComponent element, int index) { 5760 if (element == null) 5761 return; 5762 Complex t; 5763 if (Utilities.noString(parentType)) 5764 t = parent; 5765 else { 5766 t = parent.predicate("fhir:"+parentType+'.'+name); 5767 } 5768 composeBackboneElement(t, "excludedSystem", name, element, index); 5769 if (element.hasSystemElement()) 5770 composeUri(t, "ExpansionProfile", "system", element.getSystemElement(), -1); 5771 if (element.hasVersionElement()) 5772 composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1); 5773 } 5774 5775 protected void composeExpansionProfileExpansionProfileDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileDesignationComponent element, int index) { 5776 if (element == null) 5777 return; 5778 Complex t; 5779 if (Utilities.noString(parentType)) 5780 t = parent; 5781 else { 5782 t = parent.predicate("fhir:"+parentType+'.'+name); 5783 } 5784 composeBackboneElement(t, "designation", name, element, index); 5785 if (element.hasInclude()) 5786 composeExpansionProfileDesignationIncludeComponent(t, "ExpansionProfile", "include", element.getInclude(), -1); 5787 if (element.hasExclude()) 5788 composeExpansionProfileDesignationExcludeComponent(t, "ExpansionProfile", "exclude", element.getExclude(), -1); 5789 } 5790 5791 protected void composeExpansionProfileDesignationIncludeComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationIncludeComponent element, int index) { 5792 if (element == null) 5793 return; 5794 Complex t; 5795 if (Utilities.noString(parentType)) 5796 t = parent; 5797 else { 5798 t = parent.predicate("fhir:"+parentType+'.'+name); 5799 } 5800 composeBackboneElement(t, "include", name, element, index); 5801 for (int i = 0; i < element.getDesignation().size(); i++) 5802 composeExpansionProfileDesignationIncludeDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation().get(i), i); 5803 } 5804 5805 protected void composeExpansionProfileDesignationIncludeDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationIncludeDesignationComponent element, int index) { 5806 if (element == null) 5807 return; 5808 Complex t; 5809 if (Utilities.noString(parentType)) 5810 t = parent; 5811 else { 5812 t = parent.predicate("fhir:"+parentType+'.'+name); 5813 } 5814 composeBackboneElement(t, "designation", name, element, index); 5815 if (element.hasLanguageElement()) 5816 composeCode(t, "ExpansionProfile", "language", element.getLanguageElement(), -1); 5817 if (element.hasUse()) 5818 composeCoding(t, "ExpansionProfile", "use", element.getUse(), -1); 5819 } 5820 5821 protected void composeExpansionProfileDesignationExcludeComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationExcludeComponent element, int index) { 5822 if (element == null) 5823 return; 5824 Complex t; 5825 if (Utilities.noString(parentType)) 5826 t = parent; 5827 else { 5828 t = parent.predicate("fhir:"+parentType+'.'+name); 5829 } 5830 composeBackboneElement(t, "exclude", name, element, index); 5831 for (int i = 0; i < element.getDesignation().size(); i++) 5832 composeExpansionProfileDesignationExcludeDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation().get(i), i); 5833 } 5834 5835 protected void composeExpansionProfileDesignationExcludeDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationExcludeDesignationComponent element, int index) { 5836 if (element == null) 5837 return; 5838 Complex t; 5839 if (Utilities.noString(parentType)) 5840 t = parent; 5841 else { 5842 t = parent.predicate("fhir:"+parentType+'.'+name); 5843 } 5844 composeBackboneElement(t, "designation", name, element, index); 5845 if (element.hasLanguageElement()) 5846 composeCode(t, "ExpansionProfile", "language", element.getLanguageElement(), -1); 5847 if (element.hasUse()) 5848 composeCoding(t, "ExpansionProfile", "use", element.getUse(), -1); 5849 } 5850 5851 protected void composeExplanationOfBenefit(Complex parent, String parentType, String name, ExplanationOfBenefit element, int index) { 5852 if (element == null) 5853 return; 5854 Complex t; 5855 if (Utilities.noString(parentType)) 5856 t = parent; 5857 else { 5858 t = parent.predicate("fhir:"+parentType+'.'+name); 5859 } 5860 composeDomainResource(t, "ExplanationOfBenefit", name, element, index); 5861 for (int i = 0; i < element.getIdentifier().size(); i++) 5862 composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier().get(i), i); 5863 if (element.hasStatusElement()) 5864 composeEnum(t, "ExplanationOfBenefit", "status", element.getStatusElement(), -1); 5865 if (element.hasType()) 5866 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 5867 for (int i = 0; i < element.getSubType().size(); i++) 5868 composeCodeableConcept(t, "ExplanationOfBenefit", "subType", element.getSubType().get(i), i); 5869 if (element.hasPatient()) 5870 composeReference(t, "ExplanationOfBenefit", "patient", element.getPatient(), -1); 5871 if (element.hasBillablePeriod()) 5872 composePeriod(t, "ExplanationOfBenefit", "billablePeriod", element.getBillablePeriod(), -1); 5873 if (element.hasCreatedElement()) 5874 composeDateTime(t, "ExplanationOfBenefit", "created", element.getCreatedElement(), -1); 5875 if (element.hasEnterer()) 5876 composeReference(t, "ExplanationOfBenefit", "enterer", element.getEnterer(), -1); 5877 if (element.hasInsurer()) 5878 composeReference(t, "ExplanationOfBenefit", "insurer", element.getInsurer(), -1); 5879 if (element.hasProvider()) 5880 composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1); 5881 if (element.hasOrganization()) 5882 composeReference(t, "ExplanationOfBenefit", "organization", element.getOrganization(), -1); 5883 if (element.hasReferral()) 5884 composeReference(t, "ExplanationOfBenefit", "referral", element.getReferral(), -1); 5885 if (element.hasFacility()) 5886 composeReference(t, "ExplanationOfBenefit", "facility", element.getFacility(), -1); 5887 if (element.hasClaim()) 5888 composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1); 5889 if (element.hasClaimResponse()) 5890 composeReference(t, "ExplanationOfBenefit", "claimResponse", element.getClaimResponse(), -1); 5891 if (element.hasOutcome()) 5892 composeCodeableConcept(t, "ExplanationOfBenefit", "outcome", element.getOutcome(), -1); 5893 if (element.hasDispositionElement()) 5894 composeString(t, "ExplanationOfBenefit", "disposition", element.getDispositionElement(), -1); 5895 for (int i = 0; i < element.getRelated().size(); i++) 5896 composeExplanationOfBenefitRelatedClaimComponent(t, "ExplanationOfBenefit", "related", element.getRelated().get(i), i); 5897 if (element.hasPrescription()) 5898 composeReference(t, "ExplanationOfBenefit", "prescription", element.getPrescription(), -1); 5899 if (element.hasOriginalPrescription()) 5900 composeReference(t, "ExplanationOfBenefit", "originalPrescription", element.getOriginalPrescription(), -1); 5901 if (element.hasPayee()) 5902 composeExplanationOfBenefitPayeeComponent(t, "ExplanationOfBenefit", "payee", element.getPayee(), -1); 5903 for (int i = 0; i < element.getInformation().size(); i++) 5904 composeExplanationOfBenefitSupportingInformationComponent(t, "ExplanationOfBenefit", "information", element.getInformation().get(i), i); 5905 for (int i = 0; i < element.getCareTeam().size(); i++) 5906 composeExplanationOfBenefitCareTeamComponent(t, "ExplanationOfBenefit", "careTeam", element.getCareTeam().get(i), i); 5907 for (int i = 0; i < element.getDiagnosis().size(); i++) 5908 composeExplanationOfBenefitDiagnosisComponent(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis().get(i), i); 5909 for (int i = 0; i < element.getProcedure().size(); i++) 5910 composeExplanationOfBenefitProcedureComponent(t, "ExplanationOfBenefit", "procedure", element.getProcedure().get(i), i); 5911 if (element.hasPrecedenceElement()) 5912 composePositiveInt(t, "ExplanationOfBenefit", "precedence", element.getPrecedenceElement(), -1); 5913 if (element.hasInsurance()) 5914 composeExplanationOfBenefitInsuranceComponent(t, "ExplanationOfBenefit", "insurance", element.getInsurance(), -1); 5915 if (element.hasAccident()) 5916 composeExplanationOfBenefitAccidentComponent(t, "ExplanationOfBenefit", "accident", element.getAccident(), -1); 5917 if (element.hasEmploymentImpacted()) 5918 composePeriod(t, "ExplanationOfBenefit", "employmentImpacted", element.getEmploymentImpacted(), -1); 5919 if (element.hasHospitalization()) 5920 composePeriod(t, "ExplanationOfBenefit", "hospitalization", element.getHospitalization(), -1); 5921 for (int i = 0; i < element.getItem().size(); i++) 5922 composeExplanationOfBenefitItemComponent(t, "ExplanationOfBenefit", "item", element.getItem().get(i), i); 5923 for (int i = 0; i < element.getAddItem().size(); i++) 5924 composeExplanationOfBenefitAddedItemComponent(t, "ExplanationOfBenefit", "addItem", element.getAddItem().get(i), i); 5925 if (element.hasTotalCost()) 5926 composeMoney(t, "ExplanationOfBenefit", "totalCost", element.getTotalCost(), -1); 5927 if (element.hasUnallocDeductable()) 5928 composeMoney(t, "ExplanationOfBenefit", "unallocDeductable", element.getUnallocDeductable(), -1); 5929 if (element.hasTotalBenefit()) 5930 composeMoney(t, "ExplanationOfBenefit", "totalBenefit", element.getTotalBenefit(), -1); 5931 if (element.hasPayment()) 5932 composeExplanationOfBenefitPaymentComponent(t, "ExplanationOfBenefit", "payment", element.getPayment(), -1); 5933 if (element.hasForm()) 5934 composeCodeableConcept(t, "ExplanationOfBenefit", "form", element.getForm(), -1); 5935 for (int i = 0; i < element.getProcessNote().size(); i++) 5936 composeExplanationOfBenefitNoteComponent(t, "ExplanationOfBenefit", "processNote", element.getProcessNote().get(i), i); 5937 for (int i = 0; i < element.getBenefitBalance().size(); i++) 5938 composeExplanationOfBenefitBenefitBalanceComponent(t, "ExplanationOfBenefit", "benefitBalance", element.getBenefitBalance().get(i), i); 5939 } 5940 5941 protected void composeExplanationOfBenefitRelatedClaimComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.RelatedClaimComponent element, int index) { 5942 if (element == null) 5943 return; 5944 Complex t; 5945 if (Utilities.noString(parentType)) 5946 t = parent; 5947 else { 5948 t = parent.predicate("fhir:"+parentType+'.'+name); 5949 } 5950 composeBackboneElement(t, "related", name, element, index); 5951 if (element.hasClaim()) 5952 composeReference(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1); 5953 if (element.hasRelationship()) 5954 composeCodeableConcept(t, "ExplanationOfBenefit", "relationship", element.getRelationship(), -1); 5955 if (element.hasReference()) 5956 composeIdentifier(t, "ExplanationOfBenefit", "reference", element.getReference(), -1); 5957 } 5958 5959 protected void composeExplanationOfBenefitPayeeComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PayeeComponent element, int index) { 5960 if (element == null) 5961 return; 5962 Complex t; 5963 if (Utilities.noString(parentType)) 5964 t = parent; 5965 else { 5966 t = parent.predicate("fhir:"+parentType+'.'+name); 5967 } 5968 composeBackboneElement(t, "payee", name, element, index); 5969 if (element.hasType()) 5970 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 5971 if (element.hasResourceType()) 5972 composeCodeableConcept(t, "ExplanationOfBenefit", "resourceType", element.getResourceType(), -1); 5973 if (element.hasParty()) 5974 composeReference(t, "ExplanationOfBenefit", "party", element.getParty(), -1); 5975 } 5976 5977 protected void composeExplanationOfBenefitSupportingInformationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SupportingInformationComponent element, int index) { 5978 if (element == null) 5979 return; 5980 Complex t; 5981 if (Utilities.noString(parentType)) 5982 t = parent; 5983 else { 5984 t = parent.predicate("fhir:"+parentType+'.'+name); 5985 } 5986 composeBackboneElement(t, "information", name, element, index); 5987 if (element.hasSequenceElement()) 5988 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 5989 if (element.hasCategory()) 5990 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 5991 if (element.hasCode()) 5992 composeCodeableConcept(t, "ExplanationOfBenefit", "code", element.getCode(), -1); 5993 if (element.hasTiming()) 5994 composeType(t, "ExplanationOfBenefit", "timing", element.getTiming(), -1); 5995 if (element.hasValue()) 5996 composeType(t, "ExplanationOfBenefit", "value", element.getValue(), -1); 5997 if (element.hasReason()) 5998 composeCoding(t, "ExplanationOfBenefit", "reason", element.getReason(), -1); 5999 } 6000 6001 protected void composeExplanationOfBenefitCareTeamComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.CareTeamComponent element, int index) { 6002 if (element == null) 6003 return; 6004 Complex t; 6005 if (Utilities.noString(parentType)) 6006 t = parent; 6007 else { 6008 t = parent.predicate("fhir:"+parentType+'.'+name); 6009 } 6010 composeBackboneElement(t, "careTeam", name, element, index); 6011 if (element.hasSequenceElement()) 6012 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6013 if (element.hasProvider()) 6014 composeReference(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1); 6015 if (element.hasResponsibleElement()) 6016 composeBoolean(t, "ExplanationOfBenefit", "responsible", element.getResponsibleElement(), -1); 6017 if (element.hasRole()) 6018 composeCodeableConcept(t, "ExplanationOfBenefit", "role", element.getRole(), -1); 6019 if (element.hasQualification()) 6020 composeCodeableConcept(t, "ExplanationOfBenefit", "qualification", element.getQualification(), -1); 6021 } 6022 6023 protected void composeExplanationOfBenefitDiagnosisComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DiagnosisComponent element, int index) { 6024 if (element == null) 6025 return; 6026 Complex t; 6027 if (Utilities.noString(parentType)) 6028 t = parent; 6029 else { 6030 t = parent.predicate("fhir:"+parentType+'.'+name); 6031 } 6032 composeBackboneElement(t, "diagnosis", name, element, index); 6033 if (element.hasSequenceElement()) 6034 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6035 if (element.hasDiagnosis()) 6036 composeType(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis(), -1); 6037 for (int i = 0; i < element.getType().size(); i++) 6038 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType().get(i), i); 6039 if (element.hasPackageCode()) 6040 composeCodeableConcept(t, "ExplanationOfBenefit", "packageCode", element.getPackageCode(), -1); 6041 } 6042 6043 protected void composeExplanationOfBenefitProcedureComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ProcedureComponent element, int index) { 6044 if (element == null) 6045 return; 6046 Complex t; 6047 if (Utilities.noString(parentType)) 6048 t = parent; 6049 else { 6050 t = parent.predicate("fhir:"+parentType+'.'+name); 6051 } 6052 composeBackboneElement(t, "procedure", name, element, index); 6053 if (element.hasSequenceElement()) 6054 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6055 if (element.hasDateElement()) 6056 composeDateTime(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1); 6057 if (element.hasProcedure()) 6058 composeType(t, "ExplanationOfBenefit", "procedure", element.getProcedure(), -1); 6059 } 6060 6061 protected void composeExplanationOfBenefitInsuranceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.InsuranceComponent element, int index) { 6062 if (element == null) 6063 return; 6064 Complex t; 6065 if (Utilities.noString(parentType)) 6066 t = parent; 6067 else { 6068 t = parent.predicate("fhir:"+parentType+'.'+name); 6069 } 6070 composeBackboneElement(t, "insurance", name, element, index); 6071 if (element.hasCoverage()) 6072 composeReference(t, "ExplanationOfBenefit", "coverage", element.getCoverage(), -1); 6073 for (int i = 0; i < element.getPreAuthRef().size(); i++) 6074 composeString(t, "ExplanationOfBenefit", "preAuthRef", element.getPreAuthRef().get(i), i); 6075 } 6076 6077 protected void composeExplanationOfBenefitAccidentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AccidentComponent element, int index) { 6078 if (element == null) 6079 return; 6080 Complex t; 6081 if (Utilities.noString(parentType)) 6082 t = parent; 6083 else { 6084 t = parent.predicate("fhir:"+parentType+'.'+name); 6085 } 6086 composeBackboneElement(t, "accident", name, element, index); 6087 if (element.hasDateElement()) 6088 composeDate(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1); 6089 if (element.hasType()) 6090 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6091 if (element.hasLocation()) 6092 composeType(t, "ExplanationOfBenefit", "location", element.getLocation(), -1); 6093 } 6094 6095 protected void composeExplanationOfBenefitItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ItemComponent element, int index) { 6096 if (element == null) 6097 return; 6098 Complex t; 6099 if (Utilities.noString(parentType)) 6100 t = parent; 6101 else { 6102 t = parent.predicate("fhir:"+parentType+'.'+name); 6103 } 6104 composeBackboneElement(t, "item", name, element, index); 6105 if (element.hasSequenceElement()) 6106 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6107 for (int i = 0; i < element.getCareTeamLinkId().size(); i++) 6108 composePositiveInt(t, "ExplanationOfBenefit", "careTeamLinkId", element.getCareTeamLinkId().get(i), i); 6109 for (int i = 0; i < element.getDiagnosisLinkId().size(); i++) 6110 composePositiveInt(t, "ExplanationOfBenefit", "diagnosisLinkId", element.getDiagnosisLinkId().get(i), i); 6111 for (int i = 0; i < element.getProcedureLinkId().size(); i++) 6112 composePositiveInt(t, "ExplanationOfBenefit", "procedureLinkId", element.getProcedureLinkId().get(i), i); 6113 for (int i = 0; i < element.getInformationLinkId().size(); i++) 6114 composePositiveInt(t, "ExplanationOfBenefit", "informationLinkId", element.getInformationLinkId().get(i), i); 6115 if (element.hasRevenue()) 6116 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6117 if (element.hasCategory()) 6118 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6119 if (element.hasService()) 6120 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6121 for (int i = 0; i < element.getModifier().size(); i++) 6122 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6123 for (int i = 0; i < element.getProgramCode().size(); i++) 6124 composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 6125 if (element.hasServiced()) 6126 composeType(t, "ExplanationOfBenefit", "serviced", element.getServiced(), -1); 6127 if (element.hasLocation()) 6128 composeType(t, "ExplanationOfBenefit", "location", element.getLocation(), -1); 6129 if (element.hasQuantity()) 6130 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 6131 if (element.hasUnitPrice()) 6132 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 6133 if (element.hasFactorElement()) 6134 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 6135 if (element.hasNet()) 6136 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 6137 for (int i = 0; i < element.getUdi().size(); i++) 6138 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 6139 if (element.hasBodySite()) 6140 composeCodeableConcept(t, "ExplanationOfBenefit", "bodySite", element.getBodySite(), -1); 6141 for (int i = 0; i < element.getSubSite().size(); i++) 6142 composeCodeableConcept(t, "ExplanationOfBenefit", "subSite", element.getSubSite().get(i), i); 6143 for (int i = 0; i < element.getEncounter().size(); i++) 6144 composeReference(t, "ExplanationOfBenefit", "encounter", element.getEncounter().get(i), i); 6145 for (int i = 0; i < element.getNoteNumber().size(); i++) 6146 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6147 for (int i = 0; i < element.getAdjudication().size(); i++) 6148 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6149 for (int i = 0; i < element.getDetail().size(); i++) 6150 composeExplanationOfBenefitDetailComponent(t, "ExplanationOfBenefit", "detail", element.getDetail().get(i), i); 6151 } 6152 6153 protected void composeExplanationOfBenefitAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AdjudicationComponent element, int index) { 6154 if (element == null) 6155 return; 6156 Complex t; 6157 if (Utilities.noString(parentType)) 6158 t = parent; 6159 else { 6160 t = parent.predicate("fhir:"+parentType+'.'+name); 6161 } 6162 composeBackboneElement(t, "adjudication", name, element, index); 6163 if (element.hasCategory()) 6164 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6165 if (element.hasReason()) 6166 composeCodeableConcept(t, "ExplanationOfBenefit", "reason", element.getReason(), -1); 6167 if (element.hasAmount()) 6168 composeMoney(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1); 6169 if (element.hasValueElement()) 6170 composeDecimal(t, "ExplanationOfBenefit", "value", element.getValueElement(), -1); 6171 } 6172 6173 protected void composeExplanationOfBenefitDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DetailComponent element, int index) { 6174 if (element == null) 6175 return; 6176 Complex t; 6177 if (Utilities.noString(parentType)) 6178 t = parent; 6179 else { 6180 t = parent.predicate("fhir:"+parentType+'.'+name); 6181 } 6182 composeBackboneElement(t, "detail", name, element, index); 6183 if (element.hasSequenceElement()) 6184 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6185 if (element.hasType()) 6186 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6187 if (element.hasRevenue()) 6188 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6189 if (element.hasCategory()) 6190 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6191 if (element.hasService()) 6192 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6193 for (int i = 0; i < element.getModifier().size(); i++) 6194 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6195 for (int i = 0; i < element.getProgramCode().size(); i++) 6196 composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 6197 if (element.hasQuantity()) 6198 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 6199 if (element.hasUnitPrice()) 6200 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 6201 if (element.hasFactorElement()) 6202 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 6203 if (element.hasNet()) 6204 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 6205 for (int i = 0; i < element.getUdi().size(); i++) 6206 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 6207 for (int i = 0; i < element.getNoteNumber().size(); i++) 6208 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6209 for (int i = 0; i < element.getAdjudication().size(); i++) 6210 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6211 for (int i = 0; i < element.getSubDetail().size(); i++) 6212 composeExplanationOfBenefitSubDetailComponent(t, "ExplanationOfBenefit", "subDetail", element.getSubDetail().get(i), i); 6213 } 6214 6215 protected void composeExplanationOfBenefitSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SubDetailComponent element, int index) { 6216 if (element == null) 6217 return; 6218 Complex t; 6219 if (Utilities.noString(parentType)) 6220 t = parent; 6221 else { 6222 t = parent.predicate("fhir:"+parentType+'.'+name); 6223 } 6224 composeBackboneElement(t, "subDetail", name, element, index); 6225 if (element.hasSequenceElement()) 6226 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 6227 if (element.hasType()) 6228 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6229 if (element.hasRevenue()) 6230 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6231 if (element.hasCategory()) 6232 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6233 if (element.hasService()) 6234 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6235 for (int i = 0; i < element.getModifier().size(); i++) 6236 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6237 for (int i = 0; i < element.getProgramCode().size(); i++) 6238 composeCodeableConcept(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 6239 if (element.hasQuantity()) 6240 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 6241 if (element.hasUnitPrice()) 6242 composeMoney(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 6243 if (element.hasFactorElement()) 6244 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 6245 if (element.hasNet()) 6246 composeMoney(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 6247 for (int i = 0; i < element.getUdi().size(); i++) 6248 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 6249 for (int i = 0; i < element.getNoteNumber().size(); i++) 6250 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6251 for (int i = 0; i < element.getAdjudication().size(); i++) 6252 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6253 } 6254 6255 protected void composeExplanationOfBenefitAddedItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemComponent element, int index) { 6256 if (element == null) 6257 return; 6258 Complex t; 6259 if (Utilities.noString(parentType)) 6260 t = parent; 6261 else { 6262 t = parent.predicate("fhir:"+parentType+'.'+name); 6263 } 6264 composeBackboneElement(t, "addItem", name, element, index); 6265 for (int i = 0; i < element.getSequenceLinkId().size(); i++) 6266 composePositiveInt(t, "ExplanationOfBenefit", "sequenceLinkId", element.getSequenceLinkId().get(i), i); 6267 if (element.hasRevenue()) 6268 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6269 if (element.hasCategory()) 6270 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6271 if (element.hasService()) 6272 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6273 for (int i = 0; i < element.getModifier().size(); i++) 6274 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6275 if (element.hasFee()) 6276 composeMoney(t, "ExplanationOfBenefit", "fee", element.getFee(), -1); 6277 for (int i = 0; i < element.getNoteNumber().size(); i++) 6278 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6279 for (int i = 0; i < element.getAdjudication().size(); i++) 6280 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6281 for (int i = 0; i < element.getDetail().size(); i++) 6282 composeExplanationOfBenefitAddedItemsDetailComponent(t, "ExplanationOfBenefit", "detail", element.getDetail().get(i), i); 6283 } 6284 6285 protected void composeExplanationOfBenefitAddedItemsDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemsDetailComponent element, int index) { 6286 if (element == null) 6287 return; 6288 Complex t; 6289 if (Utilities.noString(parentType)) 6290 t = parent; 6291 else { 6292 t = parent.predicate("fhir:"+parentType+'.'+name); 6293 } 6294 composeBackboneElement(t, "detail", name, element, index); 6295 if (element.hasRevenue()) 6296 composeCodeableConcept(t, "ExplanationOfBenefit", "revenue", element.getRevenue(), -1); 6297 if (element.hasCategory()) 6298 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6299 if (element.hasService()) 6300 composeCodeableConcept(t, "ExplanationOfBenefit", "service", element.getService(), -1); 6301 for (int i = 0; i < element.getModifier().size(); i++) 6302 composeCodeableConcept(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 6303 if (element.hasFee()) 6304 composeMoney(t, "ExplanationOfBenefit", "fee", element.getFee(), -1); 6305 for (int i = 0; i < element.getNoteNumber().size(); i++) 6306 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 6307 for (int i = 0; i < element.getAdjudication().size(); i++) 6308 composeExplanationOfBenefitAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 6309 } 6310 6311 protected void composeExplanationOfBenefitPaymentComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PaymentComponent element, int index) { 6312 if (element == null) 6313 return; 6314 Complex t; 6315 if (Utilities.noString(parentType)) 6316 t = parent; 6317 else { 6318 t = parent.predicate("fhir:"+parentType+'.'+name); 6319 } 6320 composeBackboneElement(t, "payment", name, element, index); 6321 if (element.hasType()) 6322 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6323 if (element.hasAdjustment()) 6324 composeMoney(t, "ExplanationOfBenefit", "adjustment", element.getAdjustment(), -1); 6325 if (element.hasAdjustmentReason()) 6326 composeCodeableConcept(t, "ExplanationOfBenefit", "adjustmentReason", element.getAdjustmentReason(), -1); 6327 if (element.hasDateElement()) 6328 composeDate(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1); 6329 if (element.hasAmount()) 6330 composeMoney(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1); 6331 if (element.hasIdentifier()) 6332 composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier(), -1); 6333 } 6334 6335 protected void composeExplanationOfBenefitNoteComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.NoteComponent element, int index) { 6336 if (element == null) 6337 return; 6338 Complex t; 6339 if (Utilities.noString(parentType)) 6340 t = parent; 6341 else { 6342 t = parent.predicate("fhir:"+parentType+'.'+name); 6343 } 6344 composeBackboneElement(t, "processNote", name, element, index); 6345 if (element.hasNumberElement()) 6346 composePositiveInt(t, "ExplanationOfBenefit", "number", element.getNumberElement(), -1); 6347 if (element.hasType()) 6348 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6349 if (element.hasTextElement()) 6350 composeString(t, "ExplanationOfBenefit", "text", element.getTextElement(), -1); 6351 if (element.hasLanguage()) 6352 composeCodeableConcept(t, "ExplanationOfBenefit", "language", element.getLanguage(), -1); 6353 } 6354 6355 protected void composeExplanationOfBenefitBenefitBalanceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitBalanceComponent element, int index) { 6356 if (element == null) 6357 return; 6358 Complex t; 6359 if (Utilities.noString(parentType)) 6360 t = parent; 6361 else { 6362 t = parent.predicate("fhir:"+parentType+'.'+name); 6363 } 6364 composeBackboneElement(t, "benefitBalance", name, element, index); 6365 if (element.hasCategory()) 6366 composeCodeableConcept(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 6367 if (element.hasSubCategory()) 6368 composeCodeableConcept(t, "ExplanationOfBenefit", "subCategory", element.getSubCategory(), -1); 6369 if (element.hasExcludedElement()) 6370 composeBoolean(t, "ExplanationOfBenefit", "excluded", element.getExcludedElement(), -1); 6371 if (element.hasNameElement()) 6372 composeString(t, "ExplanationOfBenefit", "name", element.getNameElement(), -1); 6373 if (element.hasDescriptionElement()) 6374 composeString(t, "ExplanationOfBenefit", "description", element.getDescriptionElement(), -1); 6375 if (element.hasNetwork()) 6376 composeCodeableConcept(t, "ExplanationOfBenefit", "network", element.getNetwork(), -1); 6377 if (element.hasUnit()) 6378 composeCodeableConcept(t, "ExplanationOfBenefit", "unit", element.getUnit(), -1); 6379 if (element.hasTerm()) 6380 composeCodeableConcept(t, "ExplanationOfBenefit", "term", element.getTerm(), -1); 6381 for (int i = 0; i < element.getFinancial().size(); i++) 6382 composeExplanationOfBenefitBenefitComponent(t, "ExplanationOfBenefit", "financial", element.getFinancial().get(i), i); 6383 } 6384 6385 protected void composeExplanationOfBenefitBenefitComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitComponent element, int index) { 6386 if (element == null) 6387 return; 6388 Complex t; 6389 if (Utilities.noString(parentType)) 6390 t = parent; 6391 else { 6392 t = parent.predicate("fhir:"+parentType+'.'+name); 6393 } 6394 composeBackboneElement(t, "financial", name, element, index); 6395 if (element.hasType()) 6396 composeCodeableConcept(t, "ExplanationOfBenefit", "type", element.getType(), -1); 6397 if (element.hasAllowed()) 6398 composeType(t, "ExplanationOfBenefit", "allowed", element.getAllowed(), -1); 6399 if (element.hasUsed()) 6400 composeType(t, "ExplanationOfBenefit", "used", element.getUsed(), -1); 6401 } 6402 6403 protected void composeFamilyMemberHistory(Complex parent, String parentType, String name, FamilyMemberHistory element, int index) { 6404 if (element == null) 6405 return; 6406 Complex t; 6407 if (Utilities.noString(parentType)) 6408 t = parent; 6409 else { 6410 t = parent.predicate("fhir:"+parentType+'.'+name); 6411 } 6412 composeDomainResource(t, "FamilyMemberHistory", name, element, index); 6413 for (int i = 0; i < element.getIdentifier().size(); i++) 6414 composeIdentifier(t, "FamilyMemberHistory", "identifier", element.getIdentifier().get(i), i); 6415 for (int i = 0; i < element.getDefinition().size(); i++) 6416 composeReference(t, "FamilyMemberHistory", "definition", element.getDefinition().get(i), i); 6417 if (element.hasStatusElement()) 6418 composeEnum(t, "FamilyMemberHistory", "status", element.getStatusElement(), -1); 6419 if (element.hasNotDoneElement()) 6420 composeBoolean(t, "FamilyMemberHistory", "notDone", element.getNotDoneElement(), -1); 6421 if (element.hasNotDoneReason()) 6422 composeCodeableConcept(t, "FamilyMemberHistory", "notDoneReason", element.getNotDoneReason(), -1); 6423 if (element.hasPatient()) 6424 composeReference(t, "FamilyMemberHistory", "patient", element.getPatient(), -1); 6425 if (element.hasDateElement()) 6426 composeDateTime(t, "FamilyMemberHistory", "date", element.getDateElement(), -1); 6427 if (element.hasNameElement()) 6428 composeString(t, "FamilyMemberHistory", "name", element.getNameElement(), -1); 6429 if (element.hasRelationship()) 6430 composeCodeableConcept(t, "FamilyMemberHistory", "relationship", element.getRelationship(), -1); 6431 if (element.hasGenderElement()) 6432 composeEnum(t, "FamilyMemberHistory", "gender", element.getGenderElement(), -1); 6433 if (element.hasBorn()) 6434 composeType(t, "FamilyMemberHistory", "born", element.getBorn(), -1); 6435 if (element.hasAge()) 6436 composeType(t, "FamilyMemberHistory", "age", element.getAge(), -1); 6437 if (element.hasEstimatedAgeElement()) 6438 composeBoolean(t, "FamilyMemberHistory", "estimatedAge", element.getEstimatedAgeElement(), -1); 6439 if (element.hasDeceased()) 6440 composeType(t, "FamilyMemberHistory", "deceased", element.getDeceased(), -1); 6441 for (int i = 0; i < element.getReasonCode().size(); i++) 6442 composeCodeableConcept(t, "FamilyMemberHistory", "reasonCode", element.getReasonCode().get(i), i); 6443 for (int i = 0; i < element.getReasonReference().size(); i++) 6444 composeReference(t, "FamilyMemberHistory", "reasonReference", element.getReasonReference().get(i), i); 6445 for (int i = 0; i < element.getNote().size(); i++) 6446 composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i); 6447 for (int i = 0; i < element.getCondition().size(); i++) 6448 composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(t, "FamilyMemberHistory", "condition", element.getCondition().get(i), i); 6449 } 6450 6451 protected void composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryConditionComponent element, int index) { 6452 if (element == null) 6453 return; 6454 Complex t; 6455 if (Utilities.noString(parentType)) 6456 t = parent; 6457 else { 6458 t = parent.predicate("fhir:"+parentType+'.'+name); 6459 } 6460 composeBackboneElement(t, "condition", name, element, index); 6461 if (element.hasCode()) 6462 composeCodeableConcept(t, "FamilyMemberHistory", "code", element.getCode(), -1); 6463 if (element.hasOutcome()) 6464 composeCodeableConcept(t, "FamilyMemberHistory", "outcome", element.getOutcome(), -1); 6465 if (element.hasOnset()) 6466 composeType(t, "FamilyMemberHistory", "onset", element.getOnset(), -1); 6467 for (int i = 0; i < element.getNote().size(); i++) 6468 composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote().get(i), i); 6469 } 6470 6471 protected void composeFlag(Complex parent, String parentType, String name, Flag element, int index) { 6472 if (element == null) 6473 return; 6474 Complex t; 6475 if (Utilities.noString(parentType)) 6476 t = parent; 6477 else { 6478 t = parent.predicate("fhir:"+parentType+'.'+name); 6479 } 6480 composeDomainResource(t, "Flag", name, element, index); 6481 for (int i = 0; i < element.getIdentifier().size(); i++) 6482 composeIdentifier(t, "Flag", "identifier", element.getIdentifier().get(i), i); 6483 if (element.hasStatusElement()) 6484 composeEnum(t, "Flag", "status", element.getStatusElement(), -1); 6485 if (element.hasCategory()) 6486 composeCodeableConcept(t, "Flag", "category", element.getCategory(), -1); 6487 if (element.hasCode()) 6488 composeCodeableConcept(t, "Flag", "code", element.getCode(), -1); 6489 if (element.hasSubject()) 6490 composeReference(t, "Flag", "subject", element.getSubject(), -1); 6491 if (element.hasPeriod()) 6492 composePeriod(t, "Flag", "period", element.getPeriod(), -1); 6493 if (element.hasEncounter()) 6494 composeReference(t, "Flag", "encounter", element.getEncounter(), -1); 6495 if (element.hasAuthor()) 6496 composeReference(t, "Flag", "author", element.getAuthor(), -1); 6497 } 6498 6499 protected void composeGoal(Complex parent, String parentType, String name, Goal element, int index) { 6500 if (element == null) 6501 return; 6502 Complex t; 6503 if (Utilities.noString(parentType)) 6504 t = parent; 6505 else { 6506 t = parent.predicate("fhir:"+parentType+'.'+name); 6507 } 6508 composeDomainResource(t, "Goal", name, element, index); 6509 for (int i = 0; i < element.getIdentifier().size(); i++) 6510 composeIdentifier(t, "Goal", "identifier", element.getIdentifier().get(i), i); 6511 if (element.hasStatusElement()) 6512 composeEnum(t, "Goal", "status", element.getStatusElement(), -1); 6513 for (int i = 0; i < element.getCategory().size(); i++) 6514 composeCodeableConcept(t, "Goal", "category", element.getCategory().get(i), i); 6515 if (element.hasPriority()) 6516 composeCodeableConcept(t, "Goal", "priority", element.getPriority(), -1); 6517 if (element.hasDescription()) 6518 composeCodeableConcept(t, "Goal", "description", element.getDescription(), -1); 6519 if (element.hasSubject()) 6520 composeReference(t, "Goal", "subject", element.getSubject(), -1); 6521 if (element.hasStart()) 6522 composeType(t, "Goal", "start", element.getStart(), -1); 6523 if (element.hasTarget()) 6524 composeGoalGoalTargetComponent(t, "Goal", "target", element.getTarget(), -1); 6525 if (element.hasStatusDateElement()) 6526 composeDate(t, "Goal", "statusDate", element.getStatusDateElement(), -1); 6527 if (element.hasStatusReasonElement()) 6528 composeString(t, "Goal", "statusReason", element.getStatusReasonElement(), -1); 6529 if (element.hasExpressedBy()) 6530 composeReference(t, "Goal", "expressedBy", element.getExpressedBy(), -1); 6531 for (int i = 0; i < element.getAddresses().size(); i++) 6532 composeReference(t, "Goal", "addresses", element.getAddresses().get(i), i); 6533 for (int i = 0; i < element.getNote().size(); i++) 6534 composeAnnotation(t, "Goal", "note", element.getNote().get(i), i); 6535 for (int i = 0; i < element.getOutcomeCode().size(); i++) 6536 composeCodeableConcept(t, "Goal", "outcomeCode", element.getOutcomeCode().get(i), i); 6537 for (int i = 0; i < element.getOutcomeReference().size(); i++) 6538 composeReference(t, "Goal", "outcomeReference", element.getOutcomeReference().get(i), i); 6539 } 6540 6541 protected void composeGoalGoalTargetComponent(Complex parent, String parentType, String name, Goal.GoalTargetComponent element, int index) { 6542 if (element == null) 6543 return; 6544 Complex t; 6545 if (Utilities.noString(parentType)) 6546 t = parent; 6547 else { 6548 t = parent.predicate("fhir:"+parentType+'.'+name); 6549 } 6550 composeBackboneElement(t, "target", name, element, index); 6551 if (element.hasMeasure()) 6552 composeCodeableConcept(t, "Goal", "measure", element.getMeasure(), -1); 6553 if (element.hasDetail()) 6554 composeType(t, "Goal", "detail", element.getDetail(), -1); 6555 if (element.hasDue()) 6556 composeType(t, "Goal", "due", element.getDue(), -1); 6557 } 6558 6559 protected void composeGraphDefinition(Complex parent, String parentType, String name, GraphDefinition element, int index) { 6560 if (element == null) 6561 return; 6562 Complex t; 6563 if (Utilities.noString(parentType)) 6564 t = parent; 6565 else { 6566 t = parent.predicate("fhir:"+parentType+'.'+name); 6567 } 6568 composeDomainResource(t, "GraphDefinition", name, element, index); 6569 if (element.hasUrlElement()) 6570 composeUri(t, "GraphDefinition", "url", element.getUrlElement(), -1); 6571 if (element.hasVersionElement()) 6572 composeString(t, "GraphDefinition", "version", element.getVersionElement(), -1); 6573 if (element.hasNameElement()) 6574 composeString(t, "GraphDefinition", "name", element.getNameElement(), -1); 6575 if (element.hasStatusElement()) 6576 composeEnum(t, "GraphDefinition", "status", element.getStatusElement(), -1); 6577 if (element.hasExperimentalElement()) 6578 composeBoolean(t, "GraphDefinition", "experimental", element.getExperimentalElement(), -1); 6579 if (element.hasDateElement()) 6580 composeDateTime(t, "GraphDefinition", "date", element.getDateElement(), -1); 6581 if (element.hasPublisherElement()) 6582 composeString(t, "GraphDefinition", "publisher", element.getPublisherElement(), -1); 6583 for (int i = 0; i < element.getContact().size(); i++) 6584 composeContactDetail(t, "GraphDefinition", "contact", element.getContact().get(i), i); 6585 if (element.hasDescriptionElement()) 6586 composeMarkdown(t, "GraphDefinition", "description", element.getDescriptionElement(), -1); 6587 for (int i = 0; i < element.getUseContext().size(); i++) 6588 composeUsageContext(t, "GraphDefinition", "useContext", element.getUseContext().get(i), i); 6589 for (int i = 0; i < element.getJurisdiction().size(); i++) 6590 composeCodeableConcept(t, "GraphDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 6591 if (element.hasPurposeElement()) 6592 composeMarkdown(t, "GraphDefinition", "purpose", element.getPurposeElement(), -1); 6593 if (element.hasStartElement()) 6594 composeCode(t, "GraphDefinition", "start", element.getStartElement(), -1); 6595 if (element.hasProfileElement()) 6596 composeUri(t, "GraphDefinition", "profile", element.getProfileElement(), -1); 6597 for (int i = 0; i < element.getLink().size(); i++) 6598 composeGraphDefinitionGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i); 6599 } 6600 6601 protected void composeGraphDefinitionGraphDefinitionLinkComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkComponent element, int index) { 6602 if (element == null) 6603 return; 6604 Complex t; 6605 if (Utilities.noString(parentType)) 6606 t = parent; 6607 else { 6608 t = parent.predicate("fhir:"+parentType+'.'+name); 6609 } 6610 composeBackboneElement(t, "link", name, element, index); 6611 if (element.hasPathElement()) 6612 composeString(t, "GraphDefinition", "path", element.getPathElement(), -1); 6613 if (element.hasSliceNameElement()) 6614 composeString(t, "GraphDefinition", "sliceName", element.getSliceNameElement(), -1); 6615 if (element.hasMinElement()) 6616 composeInteger(t, "GraphDefinition", "min", element.getMinElement(), -1); 6617 if (element.hasMaxElement()) 6618 composeString(t, "GraphDefinition", "max", element.getMaxElement(), -1); 6619 if (element.hasDescriptionElement()) 6620 composeString(t, "GraphDefinition", "description", element.getDescriptionElement(), -1); 6621 for (int i = 0; i < element.getTarget().size(); i++) 6622 composeGraphDefinitionGraphDefinitionLinkTargetComponent(t, "GraphDefinition", "target", element.getTarget().get(i), i); 6623 } 6624 6625 protected void composeGraphDefinitionGraphDefinitionLinkTargetComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetComponent element, int index) { 6626 if (element == null) 6627 return; 6628 Complex t; 6629 if (Utilities.noString(parentType)) 6630 t = parent; 6631 else { 6632 t = parent.predicate("fhir:"+parentType+'.'+name); 6633 } 6634 composeBackboneElement(t, "target", name, element, index); 6635 if (element.hasTypeElement()) 6636 composeCode(t, "GraphDefinition", "type", element.getTypeElement(), -1); 6637 if (element.hasProfileElement()) 6638 composeUri(t, "GraphDefinition", "profile", element.getProfileElement(), -1); 6639 for (int i = 0; i < element.getCompartment().size(); i++) 6640 composeGraphDefinitionGraphDefinitionLinkTargetCompartmentComponent(t, "GraphDefinition", "compartment", element.getCompartment().get(i), i); 6641 for (int i = 0; i < element.getLink().size(); i++) 6642 composeGraphDefinitionGraphDefinitionLinkComponent(t, "GraphDefinition", "link", element.getLink().get(i), i); 6643 } 6644 6645 protected void composeGraphDefinitionGraphDefinitionLinkTargetCompartmentComponent(Complex parent, String parentType, String name, GraphDefinition.GraphDefinitionLinkTargetCompartmentComponent element, int index) { 6646 if (element == null) 6647 return; 6648 Complex t; 6649 if (Utilities.noString(parentType)) 6650 t = parent; 6651 else { 6652 t = parent.predicate("fhir:"+parentType+'.'+name); 6653 } 6654 composeBackboneElement(t, "compartment", name, element, index); 6655 if (element.hasCodeElement()) 6656 composeEnum(t, "GraphDefinition", "code", element.getCodeElement(), -1); 6657 if (element.hasRuleElement()) 6658 composeEnum(t, "GraphDefinition", "rule", element.getRuleElement(), -1); 6659 if (element.hasExpressionElement()) 6660 composeString(t, "GraphDefinition", "expression", element.getExpressionElement(), -1); 6661 if (element.hasDescriptionElement()) 6662 composeString(t, "GraphDefinition", "description", element.getDescriptionElement(), -1); 6663 } 6664 6665 protected void composeGroup(Complex parent, String parentType, String name, Group element, int index) { 6666 if (element == null) 6667 return; 6668 Complex t; 6669 if (Utilities.noString(parentType)) 6670 t = parent; 6671 else { 6672 t = parent.predicate("fhir:"+parentType+'.'+name); 6673 } 6674 composeDomainResource(t, "Group", name, element, index); 6675 for (int i = 0; i < element.getIdentifier().size(); i++) 6676 composeIdentifier(t, "Group", "identifier", element.getIdentifier().get(i), i); 6677 if (element.hasActiveElement()) 6678 composeBoolean(t, "Group", "active", element.getActiveElement(), -1); 6679 if (element.hasTypeElement()) 6680 composeEnum(t, "Group", "type", element.getTypeElement(), -1); 6681 if (element.hasActualElement()) 6682 composeBoolean(t, "Group", "actual", element.getActualElement(), -1); 6683 if (element.hasCode()) 6684 composeCodeableConcept(t, "Group", "code", element.getCode(), -1); 6685 if (element.hasNameElement()) 6686 composeString(t, "Group", "name", element.getNameElement(), -1); 6687 if (element.hasQuantityElement()) 6688 composeUnsignedInt(t, "Group", "quantity", element.getQuantityElement(), -1); 6689 for (int i = 0; i < element.getCharacteristic().size(); i++) 6690 composeGroupGroupCharacteristicComponent(t, "Group", "characteristic", element.getCharacteristic().get(i), i); 6691 for (int i = 0; i < element.getMember().size(); i++) 6692 composeGroupGroupMemberComponent(t, "Group", "member", element.getMember().get(i), i); 6693 } 6694 6695 protected void composeGroupGroupCharacteristicComponent(Complex parent, String parentType, String name, Group.GroupCharacteristicComponent element, int index) { 6696 if (element == null) 6697 return; 6698 Complex t; 6699 if (Utilities.noString(parentType)) 6700 t = parent; 6701 else { 6702 t = parent.predicate("fhir:"+parentType+'.'+name); 6703 } 6704 composeBackboneElement(t, "characteristic", name, element, index); 6705 if (element.hasCode()) 6706 composeCodeableConcept(t, "Group", "code", element.getCode(), -1); 6707 if (element.hasValue()) 6708 composeType(t, "Group", "value", element.getValue(), -1); 6709 if (element.hasExcludeElement()) 6710 composeBoolean(t, "Group", "exclude", element.getExcludeElement(), -1); 6711 if (element.hasPeriod()) 6712 composePeriod(t, "Group", "period", element.getPeriod(), -1); 6713 } 6714 6715 protected void composeGroupGroupMemberComponent(Complex parent, String parentType, String name, Group.GroupMemberComponent element, int index) { 6716 if (element == null) 6717 return; 6718 Complex t; 6719 if (Utilities.noString(parentType)) 6720 t = parent; 6721 else { 6722 t = parent.predicate("fhir:"+parentType+'.'+name); 6723 } 6724 composeBackboneElement(t, "member", name, element, index); 6725 if (element.hasEntity()) 6726 composeReference(t, "Group", "entity", element.getEntity(), -1); 6727 if (element.hasPeriod()) 6728 composePeriod(t, "Group", "period", element.getPeriod(), -1); 6729 if (element.hasInactiveElement()) 6730 composeBoolean(t, "Group", "inactive", element.getInactiveElement(), -1); 6731 } 6732 6733 protected void composeGuidanceResponse(Complex parent, String parentType, String name, GuidanceResponse element, int index) { 6734 if (element == null) 6735 return; 6736 Complex t; 6737 if (Utilities.noString(parentType)) 6738 t = parent; 6739 else { 6740 t = parent.predicate("fhir:"+parentType+'.'+name); 6741 } 6742 composeDomainResource(t, "GuidanceResponse", name, element, index); 6743 if (element.hasRequestIdElement()) 6744 composeId(t, "GuidanceResponse", "requestId", element.getRequestIdElement(), -1); 6745 if (element.hasIdentifier()) 6746 composeIdentifier(t, "GuidanceResponse", "identifier", element.getIdentifier(), -1); 6747 if (element.hasModule()) 6748 composeReference(t, "GuidanceResponse", "module", element.getModule(), -1); 6749 if (element.hasStatusElement()) 6750 composeEnum(t, "GuidanceResponse", "status", element.getStatusElement(), -1); 6751 if (element.hasSubject()) 6752 composeReference(t, "GuidanceResponse", "subject", element.getSubject(), -1); 6753 if (element.hasContext()) 6754 composeReference(t, "GuidanceResponse", "context", element.getContext(), -1); 6755 if (element.hasOccurrenceDateTimeElement()) 6756 composeDateTime(t, "GuidanceResponse", "occurrenceDateTime", element.getOccurrenceDateTimeElement(), -1); 6757 if (element.hasPerformer()) 6758 composeReference(t, "GuidanceResponse", "performer", element.getPerformer(), -1); 6759 if (element.hasReason()) 6760 composeType(t, "GuidanceResponse", "reason", element.getReason(), -1); 6761 for (int i = 0; i < element.getNote().size(); i++) 6762 composeAnnotation(t, "GuidanceResponse", "note", element.getNote().get(i), i); 6763 for (int i = 0; i < element.getEvaluationMessage().size(); i++) 6764 composeReference(t, "GuidanceResponse", "evaluationMessage", element.getEvaluationMessage().get(i), i); 6765 if (element.hasOutputParameters()) 6766 composeReference(t, "GuidanceResponse", "outputParameters", element.getOutputParameters(), -1); 6767 if (element.hasResult()) 6768 composeReference(t, "GuidanceResponse", "result", element.getResult(), -1); 6769 for (int i = 0; i < element.getDataRequirement().size(); i++) 6770 composeDataRequirement(t, "GuidanceResponse", "dataRequirement", element.getDataRequirement().get(i), i); 6771 } 6772 6773 protected void composeHealthcareService(Complex parent, String parentType, String name, HealthcareService element, int index) { 6774 if (element == null) 6775 return; 6776 Complex t; 6777 if (Utilities.noString(parentType)) 6778 t = parent; 6779 else { 6780 t = parent.predicate("fhir:"+parentType+'.'+name); 6781 } 6782 composeDomainResource(t, "HealthcareService", name, element, index); 6783 for (int i = 0; i < element.getIdentifier().size(); i++) 6784 composeIdentifier(t, "HealthcareService", "identifier", element.getIdentifier().get(i), i); 6785 if (element.hasActiveElement()) 6786 composeBoolean(t, "HealthcareService", "active", element.getActiveElement(), -1); 6787 if (element.hasProvidedBy()) 6788 composeReference(t, "HealthcareService", "providedBy", element.getProvidedBy(), -1); 6789 if (element.hasCategory()) 6790 composeCodeableConcept(t, "HealthcareService", "category", element.getCategory(), -1); 6791 for (int i = 0; i < element.getType().size(); i++) 6792 composeCodeableConcept(t, "HealthcareService", "type", element.getType().get(i), i); 6793 for (int i = 0; i < element.getSpecialty().size(); i++) 6794 composeCodeableConcept(t, "HealthcareService", "specialty", element.getSpecialty().get(i), i); 6795 for (int i = 0; i < element.getLocation().size(); i++) 6796 composeReference(t, "HealthcareService", "location", element.getLocation().get(i), i); 6797 if (element.hasNameElement()) 6798 composeString(t, "HealthcareService", "name", element.getNameElement(), -1); 6799 if (element.hasCommentElement()) 6800 composeString(t, "HealthcareService", "comment", element.getCommentElement(), -1); 6801 if (element.hasExtraDetailsElement()) 6802 composeString(t, "HealthcareService", "extraDetails", element.getExtraDetailsElement(), -1); 6803 if (element.hasPhoto()) 6804 composeAttachment(t, "HealthcareService", "photo", element.getPhoto(), -1); 6805 for (int i = 0; i < element.getTelecom().size(); i++) 6806 composeContactPoint(t, "HealthcareService", "telecom", element.getTelecom().get(i), i); 6807 for (int i = 0; i < element.getCoverageArea().size(); i++) 6808 composeReference(t, "HealthcareService", "coverageArea", element.getCoverageArea().get(i), i); 6809 for (int i = 0; i < element.getServiceProvisionCode().size(); i++) 6810 composeCodeableConcept(t, "HealthcareService", "serviceProvisionCode", element.getServiceProvisionCode().get(i), i); 6811 if (element.hasEligibility()) 6812 composeCodeableConcept(t, "HealthcareService", "eligibility", element.getEligibility(), -1); 6813 if (element.hasEligibilityNoteElement()) 6814 composeString(t, "HealthcareService", "eligibilityNote", element.getEligibilityNoteElement(), -1); 6815 for (int i = 0; i < element.getProgramName().size(); i++) 6816 composeString(t, "HealthcareService", "programName", element.getProgramName().get(i), i); 6817 for (int i = 0; i < element.getCharacteristic().size(); i++) 6818 composeCodeableConcept(t, "HealthcareService", "characteristic", element.getCharacteristic().get(i), i); 6819 for (int i = 0; i < element.getReferralMethod().size(); i++) 6820 composeCodeableConcept(t, "HealthcareService", "referralMethod", element.getReferralMethod().get(i), i); 6821 if (element.hasAppointmentRequiredElement()) 6822 composeBoolean(t, "HealthcareService", "appointmentRequired", element.getAppointmentRequiredElement(), -1); 6823 for (int i = 0; i < element.getAvailableTime().size(); i++) 6824 composeHealthcareServiceHealthcareServiceAvailableTimeComponent(t, "HealthcareService", "availableTime", element.getAvailableTime().get(i), i); 6825 for (int i = 0; i < element.getNotAvailable().size(); i++) 6826 composeHealthcareServiceHealthcareServiceNotAvailableComponent(t, "HealthcareService", "notAvailable", element.getNotAvailable().get(i), i); 6827 if (element.hasAvailabilityExceptionsElement()) 6828 composeString(t, "HealthcareService", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1); 6829 for (int i = 0; i < element.getEndpoint().size(); i++) 6830 composeReference(t, "HealthcareService", "endpoint", element.getEndpoint().get(i), i); 6831 } 6832 6833 protected void composeHealthcareServiceHealthcareServiceAvailableTimeComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceAvailableTimeComponent element, int index) { 6834 if (element == null) 6835 return; 6836 Complex t; 6837 if (Utilities.noString(parentType)) 6838 t = parent; 6839 else { 6840 t = parent.predicate("fhir:"+parentType+'.'+name); 6841 } 6842 composeBackboneElement(t, "availableTime", name, element, index); 6843 for (int i = 0; i < element.getDaysOfWeek().size(); i++) 6844 composeEnum(t, "HealthcareService", "daysOfWeek", element.getDaysOfWeek().get(i), i); 6845 if (element.hasAllDayElement()) 6846 composeBoolean(t, "HealthcareService", "allDay", element.getAllDayElement(), -1); 6847 if (element.hasAvailableStartTimeElement()) 6848 composeTime(t, "HealthcareService", "availableStartTime", element.getAvailableStartTimeElement(), -1); 6849 if (element.hasAvailableEndTimeElement()) 6850 composeTime(t, "HealthcareService", "availableEndTime", element.getAvailableEndTimeElement(), -1); 6851 } 6852 6853 protected void composeHealthcareServiceHealthcareServiceNotAvailableComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceNotAvailableComponent element, int index) { 6854 if (element == null) 6855 return; 6856 Complex t; 6857 if (Utilities.noString(parentType)) 6858 t = parent; 6859 else { 6860 t = parent.predicate("fhir:"+parentType+'.'+name); 6861 } 6862 composeBackboneElement(t, "notAvailable", name, element, index); 6863 if (element.hasDescriptionElement()) 6864 composeString(t, "HealthcareService", "description", element.getDescriptionElement(), -1); 6865 if (element.hasDuring()) 6866 composePeriod(t, "HealthcareService", "during", element.getDuring(), -1); 6867 } 6868 6869 protected void composeImagingManifest(Complex parent, String parentType, String name, ImagingManifest element, int index) { 6870 if (element == null) 6871 return; 6872 Complex t; 6873 if (Utilities.noString(parentType)) 6874 t = parent; 6875 else { 6876 t = parent.predicate("fhir:"+parentType+'.'+name); 6877 } 6878 composeDomainResource(t, "ImagingManifest", name, element, index); 6879 if (element.hasIdentifier()) 6880 composeIdentifier(t, "ImagingManifest", "identifier", element.getIdentifier(), -1); 6881 if (element.hasPatient()) 6882 composeReference(t, "ImagingManifest", "patient", element.getPatient(), -1); 6883 if (element.hasAuthoringTimeElement()) 6884 composeDateTime(t, "ImagingManifest", "authoringTime", element.getAuthoringTimeElement(), -1); 6885 if (element.hasAuthor()) 6886 composeReference(t, "ImagingManifest", "author", element.getAuthor(), -1); 6887 if (element.hasDescriptionElement()) 6888 composeString(t, "ImagingManifest", "description", element.getDescriptionElement(), -1); 6889 for (int i = 0; i < element.getStudy().size(); i++) 6890 composeImagingManifestStudyComponent(t, "ImagingManifest", "study", element.getStudy().get(i), i); 6891 } 6892 6893 protected void composeImagingManifestStudyComponent(Complex parent, String parentType, String name, ImagingManifest.StudyComponent element, int index) { 6894 if (element == null) 6895 return; 6896 Complex t; 6897 if (Utilities.noString(parentType)) 6898 t = parent; 6899 else { 6900 t = parent.predicate("fhir:"+parentType+'.'+name); 6901 } 6902 composeBackboneElement(t, "study", name, element, index); 6903 if (element.hasUidElement()) 6904 composeOid(t, "ImagingManifest", "uid", element.getUidElement(), -1); 6905 if (element.hasImagingStudy()) 6906 composeReference(t, "ImagingManifest", "imagingStudy", element.getImagingStudy(), -1); 6907 for (int i = 0; i < element.getEndpoint().size(); i++) 6908 composeReference(t, "ImagingManifest", "endpoint", element.getEndpoint().get(i), i); 6909 for (int i = 0; i < element.getSeries().size(); i++) 6910 composeImagingManifestSeriesComponent(t, "ImagingManifest", "series", element.getSeries().get(i), i); 6911 } 6912 6913 protected void composeImagingManifestSeriesComponent(Complex parent, String parentType, String name, ImagingManifest.SeriesComponent element, int index) { 6914 if (element == null) 6915 return; 6916 Complex t; 6917 if (Utilities.noString(parentType)) 6918 t = parent; 6919 else { 6920 t = parent.predicate("fhir:"+parentType+'.'+name); 6921 } 6922 composeBackboneElement(t, "series", name, element, index); 6923 if (element.hasUidElement()) 6924 composeOid(t, "ImagingManifest", "uid", element.getUidElement(), -1); 6925 for (int i = 0; i < element.getEndpoint().size(); i++) 6926 composeReference(t, "ImagingManifest", "endpoint", element.getEndpoint().get(i), i); 6927 for (int i = 0; i < element.getInstance().size(); i++) 6928 composeImagingManifestInstanceComponent(t, "ImagingManifest", "instance", element.getInstance().get(i), i); 6929 } 6930 6931 protected void composeImagingManifestInstanceComponent(Complex parent, String parentType, String name, ImagingManifest.InstanceComponent element, int index) { 6932 if (element == null) 6933 return; 6934 Complex t; 6935 if (Utilities.noString(parentType)) 6936 t = parent; 6937 else { 6938 t = parent.predicate("fhir:"+parentType+'.'+name); 6939 } 6940 composeBackboneElement(t, "instance", name, element, index); 6941 if (element.hasSopClassElement()) 6942 composeOid(t, "ImagingManifest", "sopClass", element.getSopClassElement(), -1); 6943 if (element.hasUidElement()) 6944 composeOid(t, "ImagingManifest", "uid", element.getUidElement(), -1); 6945 } 6946 6947 protected void composeImagingStudy(Complex parent, String parentType, String name, ImagingStudy element, int index) { 6948 if (element == null) 6949 return; 6950 Complex t; 6951 if (Utilities.noString(parentType)) 6952 t = parent; 6953 else { 6954 t = parent.predicate("fhir:"+parentType+'.'+name); 6955 } 6956 composeDomainResource(t, "ImagingStudy", name, element, index); 6957 if (element.hasUidElement()) 6958 composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1); 6959 if (element.hasAccession()) 6960 composeIdentifier(t, "ImagingStudy", "accession", element.getAccession(), -1); 6961 for (int i = 0; i < element.getIdentifier().size(); i++) 6962 composeIdentifier(t, "ImagingStudy", "identifier", element.getIdentifier().get(i), i); 6963 if (element.hasAvailabilityElement()) 6964 composeEnum(t, "ImagingStudy", "availability", element.getAvailabilityElement(), -1); 6965 for (int i = 0; i < element.getModalityList().size(); i++) 6966 composeCoding(t, "ImagingStudy", "modalityList", element.getModalityList().get(i), i); 6967 if (element.hasPatient()) 6968 composeReference(t, "ImagingStudy", "patient", element.getPatient(), -1); 6969 if (element.hasContext()) 6970 composeReference(t, "ImagingStudy", "context", element.getContext(), -1); 6971 if (element.hasStartedElement()) 6972 composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1); 6973 for (int i = 0; i < element.getBasedOn().size(); i++) 6974 composeReference(t, "ImagingStudy", "basedOn", element.getBasedOn().get(i), i); 6975 if (element.hasReferrer()) 6976 composeReference(t, "ImagingStudy", "referrer", element.getReferrer(), -1); 6977 for (int i = 0; i < element.getInterpreter().size(); i++) 6978 composeReference(t, "ImagingStudy", "interpreter", element.getInterpreter().get(i), i); 6979 for (int i = 0; i < element.getEndpoint().size(); i++) 6980 composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i); 6981 if (element.hasNumberOfSeriesElement()) 6982 composeUnsignedInt(t, "ImagingStudy", "numberOfSeries", element.getNumberOfSeriesElement(), -1); 6983 if (element.hasNumberOfInstancesElement()) 6984 composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1); 6985 for (int i = 0; i < element.getProcedureReference().size(); i++) 6986 composeReference(t, "ImagingStudy", "procedureReference", element.getProcedureReference().get(i), i); 6987 for (int i = 0; i < element.getProcedureCode().size(); i++) 6988 composeCodeableConcept(t, "ImagingStudy", "procedureCode", element.getProcedureCode().get(i), i); 6989 if (element.hasReason()) 6990 composeCodeableConcept(t, "ImagingStudy", "reason", element.getReason(), -1); 6991 if (element.hasDescriptionElement()) 6992 composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1); 6993 for (int i = 0; i < element.getSeries().size(); i++) 6994 composeImagingStudyImagingStudySeriesComponent(t, "ImagingStudy", "series", element.getSeries().get(i), i); 6995 } 6996 6997 protected void composeImagingStudyImagingStudySeriesComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesComponent element, int index) { 6998 if (element == null) 6999 return; 7000 Complex t; 7001 if (Utilities.noString(parentType)) 7002 t = parent; 7003 else { 7004 t = parent.predicate("fhir:"+parentType+'.'+name); 7005 } 7006 composeBackboneElement(t, "series", name, element, index); 7007 if (element.hasUidElement()) 7008 composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1); 7009 if (element.hasNumberElement()) 7010 composeUnsignedInt(t, "ImagingStudy", "number", element.getNumberElement(), -1); 7011 if (element.hasModality()) 7012 composeCoding(t, "ImagingStudy", "modality", element.getModality(), -1); 7013 if (element.hasDescriptionElement()) 7014 composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1); 7015 if (element.hasNumberOfInstancesElement()) 7016 composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1); 7017 if (element.hasAvailabilityElement()) 7018 composeEnum(t, "ImagingStudy", "availability", element.getAvailabilityElement(), -1); 7019 for (int i = 0; i < element.getEndpoint().size(); i++) 7020 composeReference(t, "ImagingStudy", "endpoint", element.getEndpoint().get(i), i); 7021 if (element.hasBodySite()) 7022 composeCoding(t, "ImagingStudy", "bodySite", element.getBodySite(), -1); 7023 if (element.hasLaterality()) 7024 composeCoding(t, "ImagingStudy", "laterality", element.getLaterality(), -1); 7025 if (element.hasStartedElement()) 7026 composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1); 7027 for (int i = 0; i < element.getPerformer().size(); i++) 7028 composeReference(t, "ImagingStudy", "performer", element.getPerformer().get(i), i); 7029 for (int i = 0; i < element.getInstance().size(); i++) 7030 composeImagingStudyImagingStudySeriesInstanceComponent(t, "ImagingStudy", "instance", element.getInstance().get(i), i); 7031 } 7032 7033 protected void composeImagingStudyImagingStudySeriesInstanceComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesInstanceComponent element, int index) { 7034 if (element == null) 7035 return; 7036 Complex t; 7037 if (Utilities.noString(parentType)) 7038 t = parent; 7039 else { 7040 t = parent.predicate("fhir:"+parentType+'.'+name); 7041 } 7042 composeBackboneElement(t, "instance", name, element, index); 7043 if (element.hasUidElement()) 7044 composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1); 7045 if (element.hasNumberElement()) 7046 composeUnsignedInt(t, "ImagingStudy", "number", element.getNumberElement(), -1); 7047 if (element.hasSopClassElement()) 7048 composeOid(t, "ImagingStudy", "sopClass", element.getSopClassElement(), -1); 7049 if (element.hasTitleElement()) 7050 composeString(t, "ImagingStudy", "title", element.getTitleElement(), -1); 7051 } 7052 7053 protected void composeImmunization(Complex parent, String parentType, String name, Immunization element, int index) { 7054 if (element == null) 7055 return; 7056 Complex t; 7057 if (Utilities.noString(parentType)) 7058 t = parent; 7059 else { 7060 t = parent.predicate("fhir:"+parentType+'.'+name); 7061 } 7062 composeDomainResource(t, "Immunization", name, element, index); 7063 for (int i = 0; i < element.getIdentifier().size(); i++) 7064 composeIdentifier(t, "Immunization", "identifier", element.getIdentifier().get(i), i); 7065 if (element.hasStatusElement()) 7066 composeEnum(t, "Immunization", "status", element.getStatusElement(), -1); 7067 if (element.hasNotGivenElement()) 7068 composeBoolean(t, "Immunization", "notGiven", element.getNotGivenElement(), -1); 7069 if (element.hasVaccineCode()) 7070 composeCodeableConcept(t, "Immunization", "vaccineCode", element.getVaccineCode(), -1); 7071 if (element.hasPatient()) 7072 composeReference(t, "Immunization", "patient", element.getPatient(), -1); 7073 if (element.hasEncounter()) 7074 composeReference(t, "Immunization", "encounter", element.getEncounter(), -1); 7075 if (element.hasDateElement()) 7076 composeDateTime(t, "Immunization", "date", element.getDateElement(), -1); 7077 if (element.hasPrimarySourceElement()) 7078 composeBoolean(t, "Immunization", "primarySource", element.getPrimarySourceElement(), -1); 7079 if (element.hasReportOrigin()) 7080 composeCodeableConcept(t, "Immunization", "reportOrigin", element.getReportOrigin(), -1); 7081 if (element.hasLocation()) 7082 composeReference(t, "Immunization", "location", element.getLocation(), -1); 7083 if (element.hasManufacturer()) 7084 composeReference(t, "Immunization", "manufacturer", element.getManufacturer(), -1); 7085 if (element.hasLotNumberElement()) 7086 composeString(t, "Immunization", "lotNumber", element.getLotNumberElement(), -1); 7087 if (element.hasExpirationDateElement()) 7088 composeDate(t, "Immunization", "expirationDate", element.getExpirationDateElement(), -1); 7089 if (element.hasSite()) 7090 composeCodeableConcept(t, "Immunization", "site", element.getSite(), -1); 7091 if (element.hasRoute()) 7092 composeCodeableConcept(t, "Immunization", "route", element.getRoute(), -1); 7093 if (element.hasDoseQuantity()) 7094 composeQuantity(t, "Immunization", "doseQuantity", element.getDoseQuantity(), -1); 7095 for (int i = 0; i < element.getPractitioner().size(); i++) 7096 composeImmunizationImmunizationPractitionerComponent(t, "Immunization", "practitioner", element.getPractitioner().get(i), i); 7097 for (int i = 0; i < element.getNote().size(); i++) 7098 composeAnnotation(t, "Immunization", "note", element.getNote().get(i), i); 7099 if (element.hasExplanation()) 7100 composeImmunizationImmunizationExplanationComponent(t, "Immunization", "explanation", element.getExplanation(), -1); 7101 for (int i = 0; i < element.getReaction().size(); i++) 7102 composeImmunizationImmunizationReactionComponent(t, "Immunization", "reaction", element.getReaction().get(i), i); 7103 for (int i = 0; i < element.getVaccinationProtocol().size(); i++) 7104 composeImmunizationImmunizationVaccinationProtocolComponent(t, "Immunization", "vaccinationProtocol", element.getVaccinationProtocol().get(i), i); 7105 } 7106 7107 protected void composeImmunizationImmunizationPractitionerComponent(Complex parent, String parentType, String name, Immunization.ImmunizationPractitionerComponent element, int index) { 7108 if (element == null) 7109 return; 7110 Complex t; 7111 if (Utilities.noString(parentType)) 7112 t = parent; 7113 else { 7114 t = parent.predicate("fhir:"+parentType+'.'+name); 7115 } 7116 composeBackboneElement(t, "practitioner", name, element, index); 7117 if (element.hasRole()) 7118 composeCodeableConcept(t, "Immunization", "role", element.getRole(), -1); 7119 if (element.hasActor()) 7120 composeReference(t, "Immunization", "actor", element.getActor(), -1); 7121 } 7122 7123 protected void composeImmunizationImmunizationExplanationComponent(Complex parent, String parentType, String name, Immunization.ImmunizationExplanationComponent element, int index) { 7124 if (element == null) 7125 return; 7126 Complex t; 7127 if (Utilities.noString(parentType)) 7128 t = parent; 7129 else { 7130 t = parent.predicate("fhir:"+parentType+'.'+name); 7131 } 7132 composeBackboneElement(t, "explanation", name, element, index); 7133 for (int i = 0; i < element.getReason().size(); i++) 7134 composeCodeableConcept(t, "Immunization", "reason", element.getReason().get(i), i); 7135 for (int i = 0; i < element.getReasonNotGiven().size(); i++) 7136 composeCodeableConcept(t, "Immunization", "reasonNotGiven", element.getReasonNotGiven().get(i), i); 7137 } 7138 7139 protected void composeImmunizationImmunizationReactionComponent(Complex parent, String parentType, String name, Immunization.ImmunizationReactionComponent element, int index) { 7140 if (element == null) 7141 return; 7142 Complex t; 7143 if (Utilities.noString(parentType)) 7144 t = parent; 7145 else { 7146 t = parent.predicate("fhir:"+parentType+'.'+name); 7147 } 7148 composeBackboneElement(t, "reaction", name, element, index); 7149 if (element.hasDateElement()) 7150 composeDateTime(t, "Immunization", "date", element.getDateElement(), -1); 7151 if (element.hasDetail()) 7152 composeReference(t, "Immunization", "detail", element.getDetail(), -1); 7153 if (element.hasReportedElement()) 7154 composeBoolean(t, "Immunization", "reported", element.getReportedElement(), -1); 7155 } 7156 7157 protected void composeImmunizationImmunizationVaccinationProtocolComponent(Complex parent, String parentType, String name, Immunization.ImmunizationVaccinationProtocolComponent element, int index) { 7158 if (element == null) 7159 return; 7160 Complex t; 7161 if (Utilities.noString(parentType)) 7162 t = parent; 7163 else { 7164 t = parent.predicate("fhir:"+parentType+'.'+name); 7165 } 7166 composeBackboneElement(t, "vaccinationProtocol", name, element, index); 7167 if (element.hasDoseSequenceElement()) 7168 composePositiveInt(t, "Immunization", "doseSequence", element.getDoseSequenceElement(), -1); 7169 if (element.hasDescriptionElement()) 7170 composeString(t, "Immunization", "description", element.getDescriptionElement(), -1); 7171 if (element.hasAuthority()) 7172 composeReference(t, "Immunization", "authority", element.getAuthority(), -1); 7173 if (element.hasSeriesElement()) 7174 composeString(t, "Immunization", "series", element.getSeriesElement(), -1); 7175 if (element.hasSeriesDosesElement()) 7176 composePositiveInt(t, "Immunization", "seriesDoses", element.getSeriesDosesElement(), -1); 7177 for (int i = 0; i < element.getTargetDisease().size(); i++) 7178 composeCodeableConcept(t, "Immunization", "targetDisease", element.getTargetDisease().get(i), i); 7179 if (element.hasDoseStatus()) 7180 composeCodeableConcept(t, "Immunization", "doseStatus", element.getDoseStatus(), -1); 7181 if (element.hasDoseStatusReason()) 7182 composeCodeableConcept(t, "Immunization", "doseStatusReason", element.getDoseStatusReason(), -1); 7183 } 7184 7185 protected void composeImmunizationRecommendation(Complex parent, String parentType, String name, ImmunizationRecommendation element, int index) { 7186 if (element == null) 7187 return; 7188 Complex t; 7189 if (Utilities.noString(parentType)) 7190 t = parent; 7191 else { 7192 t = parent.predicate("fhir:"+parentType+'.'+name); 7193 } 7194 composeDomainResource(t, "ImmunizationRecommendation", name, element, index); 7195 for (int i = 0; i < element.getIdentifier().size(); i++) 7196 composeIdentifier(t, "ImmunizationRecommendation", "identifier", element.getIdentifier().get(i), i); 7197 if (element.hasPatient()) 7198 composeReference(t, "ImmunizationRecommendation", "patient", element.getPatient(), -1); 7199 for (int i = 0; i < element.getRecommendation().size(); i++) 7200 composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(t, "ImmunizationRecommendation", "recommendation", element.getRecommendation().get(i), i); 7201 } 7202 7203 protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent element, int index) { 7204 if (element == null) 7205 return; 7206 Complex t; 7207 if (Utilities.noString(parentType)) 7208 t = parent; 7209 else { 7210 t = parent.predicate("fhir:"+parentType+'.'+name); 7211 } 7212 composeBackboneElement(t, "recommendation", name, element, index); 7213 if (element.hasDateElement()) 7214 composeDateTime(t, "ImmunizationRecommendation", "date", element.getDateElement(), -1); 7215 if (element.hasVaccineCode()) 7216 composeCodeableConcept(t, "ImmunizationRecommendation", "vaccineCode", element.getVaccineCode(), -1); 7217 if (element.hasTargetDisease()) 7218 composeCodeableConcept(t, "ImmunizationRecommendation", "targetDisease", element.getTargetDisease(), -1); 7219 if (element.hasDoseNumberElement()) 7220 composePositiveInt(t, "ImmunizationRecommendation", "doseNumber", element.getDoseNumberElement(), -1); 7221 if (element.hasForecastStatus()) 7222 composeCodeableConcept(t, "ImmunizationRecommendation", "forecastStatus", element.getForecastStatus(), -1); 7223 for (int i = 0; i < element.getDateCriterion().size(); i++) 7224 composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(t, "ImmunizationRecommendation", "dateCriterion", element.getDateCriterion().get(i), i); 7225 if (element.hasProtocol()) 7226 composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(t, "ImmunizationRecommendation", "protocol", element.getProtocol(), -1); 7227 for (int i = 0; i < element.getSupportingImmunization().size(); i++) 7228 composeReference(t, "ImmunizationRecommendation", "supportingImmunization", element.getSupportingImmunization().get(i), i); 7229 for (int i = 0; i < element.getSupportingPatientInformation().size(); i++) 7230 composeReference(t, "ImmunizationRecommendation", "supportingPatientInformation", element.getSupportingPatientInformation().get(i), i); 7231 } 7232 7233 protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent element, int index) { 7234 if (element == null) 7235 return; 7236 Complex t; 7237 if (Utilities.noString(parentType)) 7238 t = parent; 7239 else { 7240 t = parent.predicate("fhir:"+parentType+'.'+name); 7241 } 7242 composeBackboneElement(t, "dateCriterion", name, element, index); 7243 if (element.hasCode()) 7244 composeCodeableConcept(t, "ImmunizationRecommendation", "code", element.getCode(), -1); 7245 if (element.hasValueElement()) 7246 composeDateTime(t, "ImmunizationRecommendation", "value", element.getValueElement(), -1); 7247 } 7248 7249 protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent element, int index) { 7250 if (element == null) 7251 return; 7252 Complex t; 7253 if (Utilities.noString(parentType)) 7254 t = parent; 7255 else { 7256 t = parent.predicate("fhir:"+parentType+'.'+name); 7257 } 7258 composeBackboneElement(t, "protocol", name, element, index); 7259 if (element.hasDoseSequenceElement()) 7260 composePositiveInt(t, "ImmunizationRecommendation", "doseSequence", element.getDoseSequenceElement(), -1); 7261 if (element.hasDescriptionElement()) 7262 composeString(t, "ImmunizationRecommendation", "description", element.getDescriptionElement(), -1); 7263 if (element.hasAuthority()) 7264 composeReference(t, "ImmunizationRecommendation", "authority", element.getAuthority(), -1); 7265 if (element.hasSeriesElement()) 7266 composeString(t, "ImmunizationRecommendation", "series", element.getSeriesElement(), -1); 7267 } 7268 7269 protected void composeImplementationGuide(Complex parent, String parentType, String name, ImplementationGuide element, int index) { 7270 if (element == null) 7271 return; 7272 Complex t; 7273 if (Utilities.noString(parentType)) 7274 t = parent; 7275 else { 7276 t = parent.predicate("fhir:"+parentType+'.'+name); 7277 } 7278 composeDomainResource(t, "ImplementationGuide", name, element, index); 7279 if (element.hasUrlElement()) 7280 composeUri(t, "ImplementationGuide", "url", element.getUrlElement(), -1); 7281 if (element.hasVersionElement()) 7282 composeString(t, "ImplementationGuide", "version", element.getVersionElement(), -1); 7283 if (element.hasNameElement()) 7284 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 7285 if (element.hasStatusElement()) 7286 composeEnum(t, "ImplementationGuide", "status", element.getStatusElement(), -1); 7287 if (element.hasExperimentalElement()) 7288 composeBoolean(t, "ImplementationGuide", "experimental", element.getExperimentalElement(), -1); 7289 if (element.hasDateElement()) 7290 composeDateTime(t, "ImplementationGuide", "date", element.getDateElement(), -1); 7291 if (element.hasPublisherElement()) 7292 composeString(t, "ImplementationGuide", "publisher", element.getPublisherElement(), -1); 7293 for (int i = 0; i < element.getContact().size(); i++) 7294 composeContactDetail(t, "ImplementationGuide", "contact", element.getContact().get(i), i); 7295 if (element.hasDescriptionElement()) 7296 composeMarkdown(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 7297 for (int i = 0; i < element.getUseContext().size(); i++) 7298 composeUsageContext(t, "ImplementationGuide", "useContext", element.getUseContext().get(i), i); 7299 for (int i = 0; i < element.getJurisdiction().size(); i++) 7300 composeCodeableConcept(t, "ImplementationGuide", "jurisdiction", element.getJurisdiction().get(i), i); 7301 if (element.hasCopyrightElement()) 7302 composeMarkdown(t, "ImplementationGuide", "copyright", element.getCopyrightElement(), -1); 7303 if (element.hasFhirVersionElement()) 7304 composeId(t, "ImplementationGuide", "fhirVersion", element.getFhirVersionElement(), -1); 7305 for (int i = 0; i < element.getDependency().size(); i++) 7306 composeImplementationGuideImplementationGuideDependencyComponent(t, "ImplementationGuide", "dependency", element.getDependency().get(i), i); 7307 for (int i = 0; i < element.getPackage().size(); i++) 7308 composeImplementationGuideImplementationGuidePackageComponent(t, "ImplementationGuide", "package", element.getPackage().get(i), i); 7309 for (int i = 0; i < element.getGlobal().size(); i++) 7310 composeImplementationGuideImplementationGuideGlobalComponent(t, "ImplementationGuide", "global", element.getGlobal().get(i), i); 7311 for (int i = 0; i < element.getBinary().size(); i++) 7312 composeUri(t, "ImplementationGuide", "binary", element.getBinary().get(i), i); 7313 if (element.hasPage()) 7314 composeImplementationGuideImplementationGuidePageComponent(t, "ImplementationGuide", "page", element.getPage(), -1); 7315 } 7316 7317 protected void composeImplementationGuideImplementationGuideDependencyComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDependencyComponent element, int index) { 7318 if (element == null) 7319 return; 7320 Complex t; 7321 if (Utilities.noString(parentType)) 7322 t = parent; 7323 else { 7324 t = parent.predicate("fhir:"+parentType+'.'+name); 7325 } 7326 composeBackboneElement(t, "dependency", name, element, index); 7327 if (element.hasTypeElement()) 7328 composeEnum(t, "ImplementationGuide", "type", element.getTypeElement(), -1); 7329 if (element.hasUriElement()) 7330 composeUri(t, "ImplementationGuide", "uri", element.getUriElement(), -1); 7331 } 7332 7333 protected void composeImplementationGuideImplementationGuidePackageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePackageComponent element, int index) { 7334 if (element == null) 7335 return; 7336 Complex t; 7337 if (Utilities.noString(parentType)) 7338 t = parent; 7339 else { 7340 t = parent.predicate("fhir:"+parentType+'.'+name); 7341 } 7342 composeBackboneElement(t, "package", name, element, index); 7343 if (element.hasNameElement()) 7344 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 7345 if (element.hasDescriptionElement()) 7346 composeString(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 7347 for (int i = 0; i < element.getResource().size(); i++) 7348 composeImplementationGuideImplementationGuidePackageResourceComponent(t, "ImplementationGuide", "resource", element.getResource().get(i), i); 7349 } 7350 7351 protected void composeImplementationGuideImplementationGuidePackageResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePackageResourceComponent element, int index) { 7352 if (element == null) 7353 return; 7354 Complex t; 7355 if (Utilities.noString(parentType)) 7356 t = parent; 7357 else { 7358 t = parent.predicate("fhir:"+parentType+'.'+name); 7359 } 7360 composeBackboneElement(t, "resource", name, element, index); 7361 if (element.hasExampleElement()) 7362 composeBoolean(t, "ImplementationGuide", "example", element.getExampleElement(), -1); 7363 if (element.hasNameElement()) 7364 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 7365 if (element.hasDescriptionElement()) 7366 composeString(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 7367 if (element.hasAcronymElement()) 7368 composeString(t, "ImplementationGuide", "acronym", element.getAcronymElement(), -1); 7369 if (element.hasSource()) 7370 composeType(t, "ImplementationGuide", "source", element.getSource(), -1); 7371 if (element.hasExampleFor()) 7372 composeReference(t, "ImplementationGuide", "exampleFor", element.getExampleFor(), -1); 7373 } 7374 7375 protected void composeImplementationGuideImplementationGuideGlobalComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideGlobalComponent element, int index) { 7376 if (element == null) 7377 return; 7378 Complex t; 7379 if (Utilities.noString(parentType)) 7380 t = parent; 7381 else { 7382 t = parent.predicate("fhir:"+parentType+'.'+name); 7383 } 7384 composeBackboneElement(t, "global", name, element, index); 7385 if (element.hasTypeElement()) 7386 composeCode(t, "ImplementationGuide", "type", element.getTypeElement(), -1); 7387 if (element.hasProfile()) 7388 composeReference(t, "ImplementationGuide", "profile", element.getProfile(), -1); 7389 } 7390 7391 protected void composeImplementationGuideImplementationGuidePageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePageComponent element, int index) { 7392 if (element == null) 7393 return; 7394 Complex t; 7395 if (Utilities.noString(parentType)) 7396 t = parent; 7397 else { 7398 t = parent.predicate("fhir:"+parentType+'.'+name); 7399 } 7400 composeBackboneElement(t, "page", name, element, index); 7401 if (element.hasSourceElement()) 7402 composeUri(t, "ImplementationGuide", "source", element.getSourceElement(), -1); 7403 if (element.hasTitleElement()) 7404 composeString(t, "ImplementationGuide", "title", element.getTitleElement(), -1); 7405 if (element.hasKindElement()) 7406 composeEnum(t, "ImplementationGuide", "kind", element.getKindElement(), -1); 7407 for (int i = 0; i < element.getType().size(); i++) 7408 composeCode(t, "ImplementationGuide", "type", element.getType().get(i), i); 7409 for (int i = 0; i < element.getPackage().size(); i++) 7410 composeString(t, "ImplementationGuide", "package", element.getPackage().get(i), i); 7411 if (element.hasFormatElement()) 7412 composeCode(t, "ImplementationGuide", "format", element.getFormatElement(), -1); 7413 for (int i = 0; i < element.getPage().size(); i++) 7414 composeImplementationGuideImplementationGuidePageComponent(t, "ImplementationGuide", "page", element.getPage().get(i), i); 7415 } 7416 7417 protected void composeLibrary(Complex parent, String parentType, String name, Library element, int index) { 7418 if (element == null) 7419 return; 7420 Complex t; 7421 if (Utilities.noString(parentType)) 7422 t = parent; 7423 else { 7424 t = parent.predicate("fhir:"+parentType+'.'+name); 7425 } 7426 composeDomainResource(t, "Library", name, element, index); 7427 if (element.hasUrlElement()) 7428 composeUri(t, "Library", "url", element.getUrlElement(), -1); 7429 for (int i = 0; i < element.getIdentifier().size(); i++) 7430 composeIdentifier(t, "Library", "identifier", element.getIdentifier().get(i), i); 7431 if (element.hasVersionElement()) 7432 composeString(t, "Library", "version", element.getVersionElement(), -1); 7433 if (element.hasNameElement()) 7434 composeString(t, "Library", "name", element.getNameElement(), -1); 7435 if (element.hasTitleElement()) 7436 composeString(t, "Library", "title", element.getTitleElement(), -1); 7437 if (element.hasStatusElement()) 7438 composeEnum(t, "Library", "status", element.getStatusElement(), -1); 7439 if (element.hasExperimentalElement()) 7440 composeBoolean(t, "Library", "experimental", element.getExperimentalElement(), -1); 7441 if (element.hasType()) 7442 composeCodeableConcept(t, "Library", "type", element.getType(), -1); 7443 if (element.hasDateElement()) 7444 composeDateTime(t, "Library", "date", element.getDateElement(), -1); 7445 if (element.hasPublisherElement()) 7446 composeString(t, "Library", "publisher", element.getPublisherElement(), -1); 7447 if (element.hasDescriptionElement()) 7448 composeMarkdown(t, "Library", "description", element.getDescriptionElement(), -1); 7449 if (element.hasPurposeElement()) 7450 composeMarkdown(t, "Library", "purpose", element.getPurposeElement(), -1); 7451 if (element.hasUsageElement()) 7452 composeString(t, "Library", "usage", element.getUsageElement(), -1); 7453 if (element.hasApprovalDateElement()) 7454 composeDate(t, "Library", "approvalDate", element.getApprovalDateElement(), -1); 7455 if (element.hasLastReviewDateElement()) 7456 composeDate(t, "Library", "lastReviewDate", element.getLastReviewDateElement(), -1); 7457 if (element.hasEffectivePeriod()) 7458 composePeriod(t, "Library", "effectivePeriod", element.getEffectivePeriod(), -1); 7459 for (int i = 0; i < element.getUseContext().size(); i++) 7460 composeUsageContext(t, "Library", "useContext", element.getUseContext().get(i), i); 7461 for (int i = 0; i < element.getJurisdiction().size(); i++) 7462 composeCodeableConcept(t, "Library", "jurisdiction", element.getJurisdiction().get(i), i); 7463 for (int i = 0; i < element.getTopic().size(); i++) 7464 composeCodeableConcept(t, "Library", "topic", element.getTopic().get(i), i); 7465 for (int i = 0; i < element.getContributor().size(); i++) 7466 composeContributor(t, "Library", "contributor", element.getContributor().get(i), i); 7467 for (int i = 0; i < element.getContact().size(); i++) 7468 composeContactDetail(t, "Library", "contact", element.getContact().get(i), i); 7469 if (element.hasCopyrightElement()) 7470 composeMarkdown(t, "Library", "copyright", element.getCopyrightElement(), -1); 7471 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 7472 composeRelatedArtifact(t, "Library", "relatedArtifact", element.getRelatedArtifact().get(i), i); 7473 for (int i = 0; i < element.getParameter().size(); i++) 7474 composeParameterDefinition(t, "Library", "parameter", element.getParameter().get(i), i); 7475 for (int i = 0; i < element.getDataRequirement().size(); i++) 7476 composeDataRequirement(t, "Library", "dataRequirement", element.getDataRequirement().get(i), i); 7477 for (int i = 0; i < element.getContent().size(); i++) 7478 composeAttachment(t, "Library", "content", element.getContent().get(i), i); 7479 } 7480 7481 protected void composeLinkage(Complex parent, String parentType, String name, Linkage element, int index) { 7482 if (element == null) 7483 return; 7484 Complex t; 7485 if (Utilities.noString(parentType)) 7486 t = parent; 7487 else { 7488 t = parent.predicate("fhir:"+parentType+'.'+name); 7489 } 7490 composeDomainResource(t, "Linkage", name, element, index); 7491 if (element.hasActiveElement()) 7492 composeBoolean(t, "Linkage", "active", element.getActiveElement(), -1); 7493 if (element.hasAuthor()) 7494 composeReference(t, "Linkage", "author", element.getAuthor(), -1); 7495 for (int i = 0; i < element.getItem().size(); i++) 7496 composeLinkageLinkageItemComponent(t, "Linkage", "item", element.getItem().get(i), i); 7497 } 7498 7499 protected void composeLinkageLinkageItemComponent(Complex parent, String parentType, String name, Linkage.LinkageItemComponent element, int index) { 7500 if (element == null) 7501 return; 7502 Complex t; 7503 if (Utilities.noString(parentType)) 7504 t = parent; 7505 else { 7506 t = parent.predicate("fhir:"+parentType+'.'+name); 7507 } 7508 composeBackboneElement(t, "item", name, element, index); 7509 if (element.hasTypeElement()) 7510 composeEnum(t, "Linkage", "type", element.getTypeElement(), -1); 7511 if (element.hasResource()) 7512 composeReference(t, "Linkage", "resource", element.getResource(), -1); 7513 } 7514 7515 protected void composeListResource(Complex parent, String parentType, String name, ListResource element, int index) { 7516 if (element == null) 7517 return; 7518 Complex t; 7519 if (Utilities.noString(parentType)) 7520 t = parent; 7521 else { 7522 t = parent.predicate("fhir:"+parentType+'.'+name); 7523 } 7524 composeDomainResource(t, "List", name, element, index); 7525 for (int i = 0; i < element.getIdentifier().size(); i++) 7526 composeIdentifier(t, "List", "identifier", element.getIdentifier().get(i), i); 7527 if (element.hasStatusElement()) 7528 composeEnum(t, "List", "status", element.getStatusElement(), -1); 7529 if (element.hasModeElement()) 7530 composeEnum(t, "List", "mode", element.getModeElement(), -1); 7531 if (element.hasTitleElement()) 7532 composeString(t, "List", "title", element.getTitleElement(), -1); 7533 if (element.hasCode()) 7534 composeCodeableConcept(t, "List", "code", element.getCode(), -1); 7535 if (element.hasSubject()) 7536 composeReference(t, "List", "subject", element.getSubject(), -1); 7537 if (element.hasEncounter()) 7538 composeReference(t, "List", "encounter", element.getEncounter(), -1); 7539 if (element.hasDateElement()) 7540 composeDateTime(t, "List", "date", element.getDateElement(), -1); 7541 if (element.hasSource()) 7542 composeReference(t, "List", "source", element.getSource(), -1); 7543 if (element.hasOrderedBy()) 7544 composeCodeableConcept(t, "List", "orderedBy", element.getOrderedBy(), -1); 7545 for (int i = 0; i < element.getNote().size(); i++) 7546 composeAnnotation(t, "List", "note", element.getNote().get(i), i); 7547 for (int i = 0; i < element.getEntry().size(); i++) 7548 composeListResourceListEntryComponent(t, "List", "entry", element.getEntry().get(i), i); 7549 if (element.hasEmptyReason()) 7550 composeCodeableConcept(t, "List", "emptyReason", element.getEmptyReason(), -1); 7551 } 7552 7553 protected void composeListResourceListEntryComponent(Complex parent, String parentType, String name, ListResource.ListEntryComponent element, int index) { 7554 if (element == null) 7555 return; 7556 Complex t; 7557 if (Utilities.noString(parentType)) 7558 t = parent; 7559 else { 7560 t = parent.predicate("fhir:"+parentType+'.'+name); 7561 } 7562 composeBackboneElement(t, "entry", name, element, index); 7563 if (element.hasFlag()) 7564 composeCodeableConcept(t, "List", "flag", element.getFlag(), -1); 7565 if (element.hasDeletedElement()) 7566 composeBoolean(t, "List", "deleted", element.getDeletedElement(), -1); 7567 if (element.hasDateElement()) 7568 composeDateTime(t, "List", "date", element.getDateElement(), -1); 7569 if (element.hasItem()) 7570 composeReference(t, "List", "item", element.getItem(), -1); 7571 } 7572 7573 protected void composeLocation(Complex parent, String parentType, String name, Location element, int index) { 7574 if (element == null) 7575 return; 7576 Complex t; 7577 if (Utilities.noString(parentType)) 7578 t = parent; 7579 else { 7580 t = parent.predicate("fhir:"+parentType+'.'+name); 7581 } 7582 composeDomainResource(t, "Location", name, element, index); 7583 for (int i = 0; i < element.getIdentifier().size(); i++) 7584 composeIdentifier(t, "Location", "identifier", element.getIdentifier().get(i), i); 7585 if (element.hasStatusElement()) 7586 composeEnum(t, "Location", "status", element.getStatusElement(), -1); 7587 if (element.hasOperationalStatus()) 7588 composeCoding(t, "Location", "operationalStatus", element.getOperationalStatus(), -1); 7589 if (element.hasNameElement()) 7590 composeString(t, "Location", "name", element.getNameElement(), -1); 7591 for (int i = 0; i < element.getAlias().size(); i++) 7592 composeString(t, "Location", "alias", element.getAlias().get(i), i); 7593 if (element.hasDescriptionElement()) 7594 composeString(t, "Location", "description", element.getDescriptionElement(), -1); 7595 if (element.hasModeElement()) 7596 composeEnum(t, "Location", "mode", element.getModeElement(), -1); 7597 if (element.hasType()) 7598 composeCodeableConcept(t, "Location", "type", element.getType(), -1); 7599 for (int i = 0; i < element.getTelecom().size(); i++) 7600 composeContactPoint(t, "Location", "telecom", element.getTelecom().get(i), i); 7601 if (element.hasAddress()) 7602 composeAddress(t, "Location", "address", element.getAddress(), -1); 7603 if (element.hasPhysicalType()) 7604 composeCodeableConcept(t, "Location", "physicalType", element.getPhysicalType(), -1); 7605 if (element.hasPosition()) 7606 composeLocationLocationPositionComponent(t, "Location", "position", element.getPosition(), -1); 7607 if (element.hasManagingOrganization()) 7608 composeReference(t, "Location", "managingOrganization", element.getManagingOrganization(), -1); 7609 if (element.hasPartOf()) 7610 composeReference(t, "Location", "partOf", element.getPartOf(), -1); 7611 for (int i = 0; i < element.getEndpoint().size(); i++) 7612 composeReference(t, "Location", "endpoint", element.getEndpoint().get(i), i); 7613 } 7614 7615 protected void composeLocationLocationPositionComponent(Complex parent, String parentType, String name, Location.LocationPositionComponent element, int index) { 7616 if (element == null) 7617 return; 7618 Complex t; 7619 if (Utilities.noString(parentType)) 7620 t = parent; 7621 else { 7622 t = parent.predicate("fhir:"+parentType+'.'+name); 7623 } 7624 composeBackboneElement(t, "position", name, element, index); 7625 if (element.hasLongitudeElement()) 7626 composeDecimal(t, "Location", "longitude", element.getLongitudeElement(), -1); 7627 if (element.hasLatitudeElement()) 7628 composeDecimal(t, "Location", "latitude", element.getLatitudeElement(), -1); 7629 if (element.hasAltitudeElement()) 7630 composeDecimal(t, "Location", "altitude", element.getAltitudeElement(), -1); 7631 } 7632 7633 protected void composeMeasure(Complex parent, String parentType, String name, Measure element, int index) { 7634 if (element == null) 7635 return; 7636 Complex t; 7637 if (Utilities.noString(parentType)) 7638 t = parent; 7639 else { 7640 t = parent.predicate("fhir:"+parentType+'.'+name); 7641 } 7642 composeDomainResource(t, "Measure", name, element, index); 7643 if (element.hasUrlElement()) 7644 composeUri(t, "Measure", "url", element.getUrlElement(), -1); 7645 for (int i = 0; i < element.getIdentifier().size(); i++) 7646 composeIdentifier(t, "Measure", "identifier", element.getIdentifier().get(i), i); 7647 if (element.hasVersionElement()) 7648 composeString(t, "Measure", "version", element.getVersionElement(), -1); 7649 if (element.hasNameElement()) 7650 composeString(t, "Measure", "name", element.getNameElement(), -1); 7651 if (element.hasTitleElement()) 7652 composeString(t, "Measure", "title", element.getTitleElement(), -1); 7653 if (element.hasStatusElement()) 7654 composeEnum(t, "Measure", "status", element.getStatusElement(), -1); 7655 if (element.hasExperimentalElement()) 7656 composeBoolean(t, "Measure", "experimental", element.getExperimentalElement(), -1); 7657 if (element.hasDateElement()) 7658 composeDateTime(t, "Measure", "date", element.getDateElement(), -1); 7659 if (element.hasPublisherElement()) 7660 composeString(t, "Measure", "publisher", element.getPublisherElement(), -1); 7661 if (element.hasDescriptionElement()) 7662 composeMarkdown(t, "Measure", "description", element.getDescriptionElement(), -1); 7663 if (element.hasPurposeElement()) 7664 composeMarkdown(t, "Measure", "purpose", element.getPurposeElement(), -1); 7665 if (element.hasUsageElement()) 7666 composeString(t, "Measure", "usage", element.getUsageElement(), -1); 7667 if (element.hasApprovalDateElement()) 7668 composeDate(t, "Measure", "approvalDate", element.getApprovalDateElement(), -1); 7669 if (element.hasLastReviewDateElement()) 7670 composeDate(t, "Measure", "lastReviewDate", element.getLastReviewDateElement(), -1); 7671 if (element.hasEffectivePeriod()) 7672 composePeriod(t, "Measure", "effectivePeriod", element.getEffectivePeriod(), -1); 7673 for (int i = 0; i < element.getUseContext().size(); i++) 7674 composeUsageContext(t, "Measure", "useContext", element.getUseContext().get(i), i); 7675 for (int i = 0; i < element.getJurisdiction().size(); i++) 7676 composeCodeableConcept(t, "Measure", "jurisdiction", element.getJurisdiction().get(i), i); 7677 for (int i = 0; i < element.getTopic().size(); i++) 7678 composeCodeableConcept(t, "Measure", "topic", element.getTopic().get(i), i); 7679 for (int i = 0; i < element.getContributor().size(); i++) 7680 composeContributor(t, "Measure", "contributor", element.getContributor().get(i), i); 7681 for (int i = 0; i < element.getContact().size(); i++) 7682 composeContactDetail(t, "Measure", "contact", element.getContact().get(i), i); 7683 if (element.hasCopyrightElement()) 7684 composeMarkdown(t, "Measure", "copyright", element.getCopyrightElement(), -1); 7685 for (int i = 0; i < element.getRelatedArtifact().size(); i++) 7686 composeRelatedArtifact(t, "Measure", "relatedArtifact", element.getRelatedArtifact().get(i), i); 7687 for (int i = 0; i < element.getLibrary().size(); i++) 7688 composeReference(t, "Measure", "library", element.getLibrary().get(i), i); 7689 if (element.hasDisclaimerElement()) 7690 composeMarkdown(t, "Measure", "disclaimer", element.getDisclaimerElement(), -1); 7691 if (element.hasScoring()) 7692 composeCodeableConcept(t, "Measure", "scoring", element.getScoring(), -1); 7693 if (element.hasCompositeScoring()) 7694 composeCodeableConcept(t, "Measure", "compositeScoring", element.getCompositeScoring(), -1); 7695 for (int i = 0; i < element.getType().size(); i++) 7696 composeCodeableConcept(t, "Measure", "type", element.getType().get(i), i); 7697 if (element.hasRiskAdjustmentElement()) 7698 composeString(t, "Measure", "riskAdjustment", element.getRiskAdjustmentElement(), -1); 7699 if (element.hasRateAggregationElement()) 7700 composeString(t, "Measure", "rateAggregation", element.getRateAggregationElement(), -1); 7701 if (element.hasRationaleElement()) 7702 composeMarkdown(t, "Measure", "rationale", element.getRationaleElement(), -1); 7703 if (element.hasClinicalRecommendationStatementElement()) 7704 composeMarkdown(t, "Measure", "clinicalRecommendationStatement", element.getClinicalRecommendationStatementElement(), -1); 7705 if (element.hasImprovementNotationElement()) 7706 composeString(t, "Measure", "improvementNotation", element.getImprovementNotationElement(), -1); 7707 for (int i = 0; i < element.getDefinition().size(); i++) 7708 composeMarkdown(t, "Measure", "definition", element.getDefinition().get(i), i); 7709 if (element.hasGuidanceElement()) 7710 composeMarkdown(t, "Measure", "guidance", element.getGuidanceElement(), -1); 7711 if (element.hasSetElement()) 7712 composeString(t, "Measure", "set", element.getSetElement(), -1); 7713 for (int i = 0; i < element.getGroup().size(); i++) 7714 composeMeasureMeasureGroupComponent(t, "Measure", "group", element.getGroup().get(i), i); 7715 for (int i = 0; i < element.getSupplementalData().size(); i++) 7716 composeMeasureMeasureSupplementalDataComponent(t, "Measure", "supplementalData", element.getSupplementalData().get(i), i); 7717 } 7718 7719 protected void composeMeasureMeasureGroupComponent(Complex parent, String parentType, String name, Measure.MeasureGroupComponent element, int index) { 7720 if (element == null) 7721 return; 7722 Complex t; 7723 if (Utilities.noString(parentType)) 7724 t = parent; 7725 else { 7726 t = parent.predicate("fhir:"+parentType+'.'+name); 7727 } 7728 composeBackboneElement(t, "group", name, element, index); 7729 if (element.hasIdentifier()) 7730 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7731 if (element.hasNameElement()) 7732 composeString(t, "Measure", "name", element.getNameElement(), -1); 7733 if (element.hasDescriptionElement()) 7734 composeString(t, "Measure", "description", element.getDescriptionElement(), -1); 7735 for (int i = 0; i < element.getPopulation().size(); i++) 7736 composeMeasureMeasureGroupPopulationComponent(t, "Measure", "population", element.getPopulation().get(i), i); 7737 for (int i = 0; i < element.getStratifier().size(); i++) 7738 composeMeasureMeasureGroupStratifierComponent(t, "Measure", "stratifier", element.getStratifier().get(i), i); 7739 } 7740 7741 protected void composeMeasureMeasureGroupPopulationComponent(Complex parent, String parentType, String name, Measure.MeasureGroupPopulationComponent element, int index) { 7742 if (element == null) 7743 return; 7744 Complex t; 7745 if (Utilities.noString(parentType)) 7746 t = parent; 7747 else { 7748 t = parent.predicate("fhir:"+parentType+'.'+name); 7749 } 7750 composeBackboneElement(t, "population", name, element, index); 7751 if (element.hasIdentifier()) 7752 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7753 if (element.hasCode()) 7754 composeCodeableConcept(t, "Measure", "code", element.getCode(), -1); 7755 if (element.hasNameElement()) 7756 composeString(t, "Measure", "name", element.getNameElement(), -1); 7757 if (element.hasDescriptionElement()) 7758 composeString(t, "Measure", "description", element.getDescriptionElement(), -1); 7759 if (element.hasCriteriaElement()) 7760 composeString(t, "Measure", "criteria", element.getCriteriaElement(), -1); 7761 } 7762 7763 protected void composeMeasureMeasureGroupStratifierComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponent element, int index) { 7764 if (element == null) 7765 return; 7766 Complex t; 7767 if (Utilities.noString(parentType)) 7768 t = parent; 7769 else { 7770 t = parent.predicate("fhir:"+parentType+'.'+name); 7771 } 7772 composeBackboneElement(t, "stratifier", name, element, index); 7773 if (element.hasIdentifier()) 7774 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7775 if (element.hasCriteriaElement()) 7776 composeString(t, "Measure", "criteria", element.getCriteriaElement(), -1); 7777 if (element.hasPathElement()) 7778 composeString(t, "Measure", "path", element.getPathElement(), -1); 7779 } 7780 7781 protected void composeMeasureMeasureSupplementalDataComponent(Complex parent, String parentType, String name, Measure.MeasureSupplementalDataComponent element, int index) { 7782 if (element == null) 7783 return; 7784 Complex t; 7785 if (Utilities.noString(parentType)) 7786 t = parent; 7787 else { 7788 t = parent.predicate("fhir:"+parentType+'.'+name); 7789 } 7790 composeBackboneElement(t, "supplementalData", name, element, index); 7791 if (element.hasIdentifier()) 7792 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7793 for (int i = 0; i < element.getUsage().size(); i++) 7794 composeCodeableConcept(t, "Measure", "usage", element.getUsage().get(i), i); 7795 if (element.hasCriteriaElement()) 7796 composeString(t, "Measure", "criteria", element.getCriteriaElement(), -1); 7797 if (element.hasPathElement()) 7798 composeString(t, "Measure", "path", element.getPathElement(), -1); 7799 } 7800 7801 protected void composeMeasureReport(Complex parent, String parentType, String name, MeasureReport element, int index) { 7802 if (element == null) 7803 return; 7804 Complex t; 7805 if (Utilities.noString(parentType)) 7806 t = parent; 7807 else { 7808 t = parent.predicate("fhir:"+parentType+'.'+name); 7809 } 7810 composeDomainResource(t, "MeasureReport", name, element, index); 7811 if (element.hasIdentifier()) 7812 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7813 if (element.hasStatusElement()) 7814 composeEnum(t, "MeasureReport", "status", element.getStatusElement(), -1); 7815 if (element.hasTypeElement()) 7816 composeEnum(t, "MeasureReport", "type", element.getTypeElement(), -1); 7817 if (element.hasMeasure()) 7818 composeReference(t, "MeasureReport", "measure", element.getMeasure(), -1); 7819 if (element.hasPatient()) 7820 composeReference(t, "MeasureReport", "patient", element.getPatient(), -1); 7821 if (element.hasDateElement()) 7822 composeDateTime(t, "MeasureReport", "date", element.getDateElement(), -1); 7823 if (element.hasReportingOrganization()) 7824 composeReference(t, "MeasureReport", "reportingOrganization", element.getReportingOrganization(), -1); 7825 if (element.hasPeriod()) 7826 composePeriod(t, "MeasureReport", "period", element.getPeriod(), -1); 7827 for (int i = 0; i < element.getGroup().size(); i++) 7828 composeMeasureReportMeasureReportGroupComponent(t, "MeasureReport", "group", element.getGroup().get(i), i); 7829 if (element.hasEvaluatedResources()) 7830 composeReference(t, "MeasureReport", "evaluatedResources", element.getEvaluatedResources(), -1); 7831 } 7832 7833 protected void composeMeasureReportMeasureReportGroupComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupComponent element, int index) { 7834 if (element == null) 7835 return; 7836 Complex t; 7837 if (Utilities.noString(parentType)) 7838 t = parent; 7839 else { 7840 t = parent.predicate("fhir:"+parentType+'.'+name); 7841 } 7842 composeBackboneElement(t, "group", name, element, index); 7843 if (element.hasIdentifier()) 7844 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7845 for (int i = 0; i < element.getPopulation().size(); i++) 7846 composeMeasureReportMeasureReportGroupPopulationComponent(t, "MeasureReport", "population", element.getPopulation().get(i), i); 7847 if (element.hasMeasureScoreElement()) 7848 composeDecimal(t, "MeasureReport", "measureScore", element.getMeasureScoreElement(), -1); 7849 for (int i = 0; i < element.getStratifier().size(); i++) 7850 composeMeasureReportMeasureReportGroupStratifierComponent(t, "MeasureReport", "stratifier", element.getStratifier().get(i), i); 7851 } 7852 7853 protected void composeMeasureReportMeasureReportGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupPopulationComponent element, int index) { 7854 if (element == null) 7855 return; 7856 Complex t; 7857 if (Utilities.noString(parentType)) 7858 t = parent; 7859 else { 7860 t = parent.predicate("fhir:"+parentType+'.'+name); 7861 } 7862 composeBackboneElement(t, "population", name, element, index); 7863 if (element.hasIdentifier()) 7864 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7865 if (element.hasCode()) 7866 composeCodeableConcept(t, "MeasureReport", "code", element.getCode(), -1); 7867 if (element.hasCountElement()) 7868 composeInteger(t, "MeasureReport", "count", element.getCountElement(), -1); 7869 if (element.hasPatients()) 7870 composeReference(t, "MeasureReport", "patients", element.getPatients(), -1); 7871 } 7872 7873 protected void composeMeasureReportMeasureReportGroupStratifierComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupStratifierComponent element, int index) { 7874 if (element == null) 7875 return; 7876 Complex t; 7877 if (Utilities.noString(parentType)) 7878 t = parent; 7879 else { 7880 t = parent.predicate("fhir:"+parentType+'.'+name); 7881 } 7882 composeBackboneElement(t, "stratifier", name, element, index); 7883 if (element.hasIdentifier()) 7884 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7885 for (int i = 0; i < element.getStratum().size(); i++) 7886 composeMeasureReportStratifierGroupComponent(t, "MeasureReport", "stratum", element.getStratum().get(i), i); 7887 } 7888 7889 protected void composeMeasureReportStratifierGroupComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupComponent element, int index) { 7890 if (element == null) 7891 return; 7892 Complex t; 7893 if (Utilities.noString(parentType)) 7894 t = parent; 7895 else { 7896 t = parent.predicate("fhir:"+parentType+'.'+name); 7897 } 7898 composeBackboneElement(t, "stratum", name, element, index); 7899 if (element.hasValueElement()) 7900 composeString(t, "MeasureReport", "value", element.getValueElement(), -1); 7901 for (int i = 0; i < element.getPopulation().size(); i++) 7902 composeMeasureReportStratifierGroupPopulationComponent(t, "MeasureReport", "population", element.getPopulation().get(i), i); 7903 if (element.hasMeasureScoreElement()) 7904 composeDecimal(t, "MeasureReport", "measureScore", element.getMeasureScoreElement(), -1); 7905 } 7906 7907 protected void composeMeasureReportStratifierGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.StratifierGroupPopulationComponent element, int index) { 7908 if (element == null) 7909 return; 7910 Complex t; 7911 if (Utilities.noString(parentType)) 7912 t = parent; 7913 else { 7914 t = parent.predicate("fhir:"+parentType+'.'+name); 7915 } 7916 composeBackboneElement(t, "population", name, element, index); 7917 if (element.hasIdentifier()) 7918 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7919 if (element.hasCode()) 7920 composeCodeableConcept(t, "MeasureReport", "code", element.getCode(), -1); 7921 if (element.hasCountElement()) 7922 composeInteger(t, "MeasureReport", "count", element.getCountElement(), -1); 7923 if (element.hasPatients()) 7924 composeReference(t, "MeasureReport", "patients", element.getPatients(), -1); 7925 } 7926 7927 protected void composeMedia(Complex parent, String parentType, String name, Media element, int index) { 7928 if (element == null) 7929 return; 7930 Complex t; 7931 if (Utilities.noString(parentType)) 7932 t = parent; 7933 else { 7934 t = parent.predicate("fhir:"+parentType+'.'+name); 7935 } 7936 composeDomainResource(t, "Media", name, element, index); 7937 for (int i = 0; i < element.getIdentifier().size(); i++) 7938 composeIdentifier(t, "Media", "identifier", element.getIdentifier().get(i), i); 7939 for (int i = 0; i < element.getBasedOn().size(); i++) 7940 composeReference(t, "Media", "basedOn", element.getBasedOn().get(i), i); 7941 if (element.hasTypeElement()) 7942 composeEnum(t, "Media", "type", element.getTypeElement(), -1); 7943 if (element.hasSubtype()) 7944 composeCodeableConcept(t, "Media", "subtype", element.getSubtype(), -1); 7945 if (element.hasView()) 7946 composeCodeableConcept(t, "Media", "view", element.getView(), -1); 7947 if (element.hasSubject()) 7948 composeReference(t, "Media", "subject", element.getSubject(), -1); 7949 if (element.hasContext()) 7950 composeReference(t, "Media", "context", element.getContext(), -1); 7951 if (element.hasOccurrence()) 7952 composeType(t, "Media", "occurrence", element.getOccurrence(), -1); 7953 if (element.hasOperator()) 7954 composeReference(t, "Media", "operator", element.getOperator(), -1); 7955 for (int i = 0; i < element.getReasonCode().size(); i++) 7956 composeCodeableConcept(t, "Media", "reasonCode", element.getReasonCode().get(i), i); 7957 if (element.hasBodySite()) 7958 composeCodeableConcept(t, "Media", "bodySite", element.getBodySite(), -1); 7959 if (element.hasDevice()) 7960 composeReference(t, "Media", "device", element.getDevice(), -1); 7961 if (element.hasHeightElement()) 7962 composePositiveInt(t, "Media", "height", element.getHeightElement(), -1); 7963 if (element.hasWidthElement()) 7964 composePositiveInt(t, "Media", "width", element.getWidthElement(), -1); 7965 if (element.hasFramesElement()) 7966 composePositiveInt(t, "Media", "frames", element.getFramesElement(), -1); 7967 if (element.hasDurationElement()) 7968 composeUnsignedInt(t, "Media", "duration", element.getDurationElement(), -1); 7969 if (element.hasContent()) 7970 composeAttachment(t, "Media", "content", element.getContent(), -1); 7971 for (int i = 0; i < element.getNote().size(); i++) 7972 composeAnnotation(t, "Media", "note", element.getNote().get(i), i); 7973 } 7974 7975 protected void composeMedication(Complex parent, String parentType, String name, Medication element, int index) { 7976 if (element == null) 7977 return; 7978 Complex t; 7979 if (Utilities.noString(parentType)) 7980 t = parent; 7981 else { 7982 t = parent.predicate("fhir:"+parentType+'.'+name); 7983 } 7984 composeDomainResource(t, "Medication", name, element, index); 7985 if (element.hasCode()) 7986 composeCodeableConcept(t, "Medication", "code", element.getCode(), -1); 7987 if (element.hasStatusElement()) 7988 composeEnum(t, "Medication", "status", element.getStatusElement(), -1); 7989 if (element.hasIsBrandElement()) 7990 composeBoolean(t, "Medication", "isBrand", element.getIsBrandElement(), -1); 7991 if (element.hasIsOverTheCounterElement()) 7992 composeBoolean(t, "Medication", "isOverTheCounter", element.getIsOverTheCounterElement(), -1); 7993 if (element.hasManufacturer()) 7994 composeReference(t, "Medication", "manufacturer", element.getManufacturer(), -1); 7995 if (element.hasForm()) 7996 composeCodeableConcept(t, "Medication", "form", element.getForm(), -1); 7997 for (int i = 0; i < element.getIngredient().size(); i++) 7998 composeMedicationMedicationIngredientComponent(t, "Medication", "ingredient", element.getIngredient().get(i), i); 7999 if (element.hasPackage()) 8000 composeMedicationMedicationPackageComponent(t, "Medication", "package", element.getPackage(), -1); 8001 for (int i = 0; i < element.getImage().size(); i++) 8002 composeAttachment(t, "Medication", "image", element.getImage().get(i), i); 8003 } 8004 8005 protected void composeMedicationMedicationIngredientComponent(Complex parent, String parentType, String name, Medication.MedicationIngredientComponent element, int index) { 8006 if (element == null) 8007 return; 8008 Complex t; 8009 if (Utilities.noString(parentType)) 8010 t = parent; 8011 else { 8012 t = parent.predicate("fhir:"+parentType+'.'+name); 8013 } 8014 composeBackboneElement(t, "ingredient", name, element, index); 8015 if (element.hasItem()) 8016 composeType(t, "Medication", "item", element.getItem(), -1); 8017 if (element.hasIsActiveElement()) 8018 composeBoolean(t, "Medication", "isActive", element.getIsActiveElement(), -1); 8019 if (element.hasAmount()) 8020 composeRatio(t, "Medication", "amount", element.getAmount(), -1); 8021 } 8022 8023 protected void composeMedicationMedicationPackageComponent(Complex parent, String parentType, String name, Medication.MedicationPackageComponent element, int index) { 8024 if (element == null) 8025 return; 8026 Complex t; 8027 if (Utilities.noString(parentType)) 8028 t = parent; 8029 else { 8030 t = parent.predicate("fhir:"+parentType+'.'+name); 8031 } 8032 composeBackboneElement(t, "package", name, element, index); 8033 if (element.hasContainer()) 8034 composeCodeableConcept(t, "Medication", "container", element.getContainer(), -1); 8035 for (int i = 0; i < element.getContent().size(); i++) 8036 composeMedicationMedicationPackageContentComponent(t, "Medication", "content", element.getContent().get(i), i); 8037 for (int i = 0; i < element.getBatch().size(); i++) 8038 composeMedicationMedicationPackageBatchComponent(t, "Medication", "batch", element.getBatch().get(i), i); 8039 } 8040 8041 protected void composeMedicationMedicationPackageContentComponent(Complex parent, String parentType, String name, Medication.MedicationPackageContentComponent element, int index) { 8042 if (element == null) 8043 return; 8044 Complex t; 8045 if (Utilities.noString(parentType)) 8046 t = parent; 8047 else { 8048 t = parent.predicate("fhir:"+parentType+'.'+name); 8049 } 8050 composeBackboneElement(t, "content", name, element, index); 8051 if (element.hasItem()) 8052 composeType(t, "Medication", "item", element.getItem(), -1); 8053 if (element.hasAmount()) 8054 composeQuantity(t, "Medication", "amount", element.getAmount(), -1); 8055 } 8056 8057 protected void composeMedicationMedicationPackageBatchComponent(Complex parent, String parentType, String name, Medication.MedicationPackageBatchComponent element, int index) { 8058 if (element == null) 8059 return; 8060 Complex t; 8061 if (Utilities.noString(parentType)) 8062 t = parent; 8063 else { 8064 t = parent.predicate("fhir:"+parentType+'.'+name); 8065 } 8066 composeBackboneElement(t, "batch", name, element, index); 8067 if (element.hasLotNumberElement()) 8068 composeString(t, "Medication", "lotNumber", element.getLotNumberElement(), -1); 8069 if (element.hasExpirationDateElement()) 8070 composeDateTime(t, "Medication", "expirationDate", element.getExpirationDateElement(), -1); 8071 } 8072 8073 protected void composeMedicationAdministration(Complex parent, String parentType, String name, MedicationAdministration element, int index) { 8074 if (element == null) 8075 return; 8076 Complex t; 8077 if (Utilities.noString(parentType)) 8078 t = parent; 8079 else { 8080 t = parent.predicate("fhir:"+parentType+'.'+name); 8081 } 8082 composeDomainResource(t, "MedicationAdministration", name, element, index); 8083 for (int i = 0; i < element.getIdentifier().size(); i++) 8084 composeIdentifier(t, "MedicationAdministration", "identifier", element.getIdentifier().get(i), i); 8085 for (int i = 0; i < element.getDefinition().size(); i++) 8086 composeReference(t, "MedicationAdministration", "definition", element.getDefinition().get(i), i); 8087 for (int i = 0; i < element.getPartOf().size(); i++) 8088 composeReference(t, "MedicationAdministration", "partOf", element.getPartOf().get(i), i); 8089 if (element.hasStatusElement()) 8090 composeEnum(t, "MedicationAdministration", "status", element.getStatusElement(), -1); 8091 if (element.hasCategory()) 8092 composeCodeableConcept(t, "MedicationAdministration", "category", element.getCategory(), -1); 8093 if (element.hasMedication()) 8094 composeType(t, "MedicationAdministration", "medication", element.getMedication(), -1); 8095 if (element.hasSubject()) 8096 composeReference(t, "MedicationAdministration", "subject", element.getSubject(), -1); 8097 if (element.hasContext()) 8098 composeReference(t, "MedicationAdministration", "context", element.getContext(), -1); 8099 for (int i = 0; i < element.getSupportingInformation().size(); i++) 8100 composeReference(t, "MedicationAdministration", "supportingInformation", element.getSupportingInformation().get(i), i); 8101 if (element.hasEffective()) 8102 composeType(t, "MedicationAdministration", "effective", element.getEffective(), -1); 8103 for (int i = 0; i < element.getPerformer().size(); i++) 8104 composeMedicationAdministrationMedicationAdministrationPerformerComponent(t, "MedicationAdministration", "performer", element.getPerformer().get(i), i); 8105 if (element.hasNotGivenElement()) 8106 composeBoolean(t, "MedicationAdministration", "notGiven", element.getNotGivenElement(), -1); 8107 for (int i = 0; i < element.getReasonNotGiven().size(); i++) 8108 composeCodeableConcept(t, "MedicationAdministration", "reasonNotGiven", element.getReasonNotGiven().get(i), i); 8109 for (int i = 0; i < element.getReasonCode().size(); i++) 8110 composeCodeableConcept(t, "MedicationAdministration", "reasonCode", element.getReasonCode().get(i), i); 8111 for (int i = 0; i < element.getReasonReference().size(); i++) 8112 composeReference(t, "MedicationAdministration", "reasonReference", element.getReasonReference().get(i), i); 8113 if (element.hasPrescription()) 8114 composeReference(t, "MedicationAdministration", "prescription", element.getPrescription(), -1); 8115 for (int i = 0; i < element.getDevice().size(); i++) 8116 composeReference(t, "MedicationAdministration", "device", element.getDevice().get(i), i); 8117 for (int i = 0; i < element.getNote().size(); i++) 8118 composeAnnotation(t, "MedicationAdministration", "note", element.getNote().get(i), i); 8119 if (element.hasDosage()) 8120 composeMedicationAdministrationMedicationAdministrationDosageComponent(t, "MedicationAdministration", "dosage", element.getDosage(), -1); 8121 for (int i = 0; i < element.getEventHistory().size(); i++) 8122 composeReference(t, "MedicationAdministration", "eventHistory", element.getEventHistory().get(i), i); 8123 } 8124 8125 protected void composeMedicationAdministrationMedicationAdministrationPerformerComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationPerformerComponent element, int index) { 8126 if (element == null) 8127 return; 8128 Complex t; 8129 if (Utilities.noString(parentType)) 8130 t = parent; 8131 else { 8132 t = parent.predicate("fhir:"+parentType+'.'+name); 8133 } 8134 composeBackboneElement(t, "performer", name, element, index); 8135 if (element.hasActor()) 8136 composeReference(t, "MedicationAdministration", "actor", element.getActor(), -1); 8137 if (element.hasOnBehalfOf()) 8138 composeReference(t, "MedicationAdministration", "onBehalfOf", element.getOnBehalfOf(), -1); 8139 } 8140 8141 protected void composeMedicationAdministrationMedicationAdministrationDosageComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationDosageComponent element, int index) { 8142 if (element == null) 8143 return; 8144 Complex t; 8145 if (Utilities.noString(parentType)) 8146 t = parent; 8147 else { 8148 t = parent.predicate("fhir:"+parentType+'.'+name); 8149 } 8150 composeBackboneElement(t, "dosage", name, element, index); 8151 if (element.hasTextElement()) 8152 composeString(t, "MedicationAdministration", "text", element.getTextElement(), -1); 8153 if (element.hasSite()) 8154 composeCodeableConcept(t, "MedicationAdministration", "site", element.getSite(), -1); 8155 if (element.hasRoute()) 8156 composeCodeableConcept(t, "MedicationAdministration", "route", element.getRoute(), -1); 8157 if (element.hasMethod()) 8158 composeCodeableConcept(t, "MedicationAdministration", "method", element.getMethod(), -1); 8159 if (element.hasDose()) 8160 composeQuantity(t, "MedicationAdministration", "dose", element.getDose(), -1); 8161 if (element.hasRate()) 8162 composeType(t, "MedicationAdministration", "rate", element.getRate(), -1); 8163 } 8164 8165 protected void composeMedicationDispense(Complex parent, String parentType, String name, MedicationDispense element, int index) { 8166 if (element == null) 8167 return; 8168 Complex t; 8169 if (Utilities.noString(parentType)) 8170 t = parent; 8171 else { 8172 t = parent.predicate("fhir:"+parentType+'.'+name); 8173 } 8174 composeDomainResource(t, "MedicationDispense", name, element, index); 8175 for (int i = 0; i < element.getIdentifier().size(); i++) 8176 composeIdentifier(t, "MedicationDispense", "identifier", element.getIdentifier().get(i), i); 8177 for (int i = 0; i < element.getPartOf().size(); i++) 8178 composeReference(t, "MedicationDispense", "partOf", element.getPartOf().get(i), i); 8179 if (element.hasStatusElement()) 8180 composeEnum(t, "MedicationDispense", "status", element.getStatusElement(), -1); 8181 if (element.hasCategory()) 8182 composeCodeableConcept(t, "MedicationDispense", "category", element.getCategory(), -1); 8183 if (element.hasMedication()) 8184 composeType(t, "MedicationDispense", "medication", element.getMedication(), -1); 8185 if (element.hasSubject()) 8186 composeReference(t, "MedicationDispense", "subject", element.getSubject(), -1); 8187 if (element.hasContext()) 8188 composeReference(t, "MedicationDispense", "context", element.getContext(), -1); 8189 for (int i = 0; i < element.getSupportingInformation().size(); i++) 8190 composeReference(t, "MedicationDispense", "supportingInformation", element.getSupportingInformation().get(i), i); 8191 for (int i = 0; i < element.getPerformer().size(); i++) 8192 composeMedicationDispenseMedicationDispensePerformerComponent(t, "MedicationDispense", "performer", element.getPerformer().get(i), i); 8193 for (int i = 0; i < element.getAuthorizingPrescription().size(); i++) 8194 composeReference(t, "MedicationDispense", "authorizingPrescription", element.getAuthorizingPrescription().get(i), i); 8195 if (element.hasType()) 8196 composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1); 8197 if (element.hasQuantity()) 8198 composeQuantity(t, "MedicationDispense", "quantity", element.getQuantity(), -1); 8199 if (element.hasDaysSupply()) 8200 composeQuantity(t, "MedicationDispense", "daysSupply", element.getDaysSupply(), -1); 8201 if (element.hasWhenPreparedElement()) 8202 composeDateTime(t, "MedicationDispense", "whenPrepared", element.getWhenPreparedElement(), -1); 8203 if (element.hasWhenHandedOverElement()) 8204 composeDateTime(t, "MedicationDispense", "whenHandedOver", element.getWhenHandedOverElement(), -1); 8205 if (element.hasDestination()) 8206 composeReference(t, "MedicationDispense", "destination", element.getDestination(), -1); 8207 for (int i = 0; i < element.getReceiver().size(); i++) 8208 composeReference(t, "MedicationDispense", "receiver", element.getReceiver().get(i), i); 8209 for (int i = 0; i < element.getNote().size(); i++) 8210 composeAnnotation(t, "MedicationDispense", "note", element.getNote().get(i), i); 8211 for (int i = 0; i < element.getDosageInstruction().size(); i++) 8212 composeDosage(t, "MedicationDispense", "dosageInstruction", element.getDosageInstruction().get(i), i); 8213 if (element.hasSubstitution()) 8214 composeMedicationDispenseMedicationDispenseSubstitutionComponent(t, "MedicationDispense", "substitution", element.getSubstitution(), -1); 8215 for (int i = 0; i < element.getDetectedIssue().size(); i++) 8216 composeReference(t, "MedicationDispense", "detectedIssue", element.getDetectedIssue().get(i), i); 8217 if (element.hasNotDoneElement()) 8218 composeBoolean(t, "MedicationDispense", "notDone", element.getNotDoneElement(), -1); 8219 if (element.hasNotDoneReason()) 8220 composeType(t, "MedicationDispense", "notDoneReason", element.getNotDoneReason(), -1); 8221 for (int i = 0; i < element.getEventHistory().size(); i++) 8222 composeReference(t, "MedicationDispense", "eventHistory", element.getEventHistory().get(i), i); 8223 } 8224 8225 protected void composeMedicationDispenseMedicationDispensePerformerComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispensePerformerComponent element, int index) { 8226 if (element == null) 8227 return; 8228 Complex t; 8229 if (Utilities.noString(parentType)) 8230 t = parent; 8231 else { 8232 t = parent.predicate("fhir:"+parentType+'.'+name); 8233 } 8234 composeBackboneElement(t, "performer", name, element, index); 8235 if (element.hasActor()) 8236 composeReference(t, "MedicationDispense", "actor", element.getActor(), -1); 8237 if (element.hasOnBehalfOf()) 8238 composeReference(t, "MedicationDispense", "onBehalfOf", element.getOnBehalfOf(), -1); 8239 } 8240 8241 protected void composeMedicationDispenseMedicationDispenseSubstitutionComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispenseSubstitutionComponent element, int index) { 8242 if (element == null) 8243 return; 8244 Complex t; 8245 if (Utilities.noString(parentType)) 8246 t = parent; 8247 else { 8248 t = parent.predicate("fhir:"+parentType+'.'+name); 8249 } 8250 composeBackboneElement(t, "substitution", name, element, index); 8251 if (element.hasWasSubstitutedElement()) 8252 composeBoolean(t, "MedicationDispense", "wasSubstituted", element.getWasSubstitutedElement(), -1); 8253 if (element.hasType()) 8254 composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1); 8255 for (int i = 0; i < element.getReason().size(); i++) 8256 composeCodeableConcept(t, "MedicationDispense", "reason", element.getReason().get(i), i); 8257 for (int i = 0; i < element.getResponsibleParty().size(); i++) 8258 composeReference(t, "MedicationDispense", "responsibleParty", element.getResponsibleParty().get(i), i); 8259 } 8260 8261 protected void composeMedicationRequest(Complex parent, String parentType, String name, MedicationRequest element, int index) { 8262 if (element == null) 8263 return; 8264 Complex t; 8265 if (Utilities.noString(parentType)) 8266 t = parent; 8267 else { 8268 t = parent.predicate("fhir:"+parentType+'.'+name); 8269 } 8270 composeDomainResource(t, "MedicationRequest", name, element, index); 8271 for (int i = 0; i < element.getIdentifier().size(); i++) 8272 composeIdentifier(t, "MedicationRequest", "identifier", element.getIdentifier().get(i), i); 8273 for (int i = 0; i < element.getDefinition().size(); i++) 8274 composeReference(t, "MedicationRequest", "definition", element.getDefinition().get(i), i); 8275 for (int i = 0; i < element.getBasedOn().size(); i++) 8276 composeReference(t, "MedicationRequest", "basedOn", element.getBasedOn().get(i), i); 8277 if (element.hasGroupIdentifier()) 8278 composeIdentifier(t, "MedicationRequest", "groupIdentifier", element.getGroupIdentifier(), -1); 8279 if (element.hasStatusElement()) 8280 composeEnum(t, "MedicationRequest", "status", element.getStatusElement(), -1); 8281 if (element.hasIntentElement()) 8282 composeEnum(t, "MedicationRequest", "intent", element.getIntentElement(), -1); 8283 if (element.hasCategory()) 8284 composeCodeableConcept(t, "MedicationRequest", "category", element.getCategory(), -1); 8285 if (element.hasPriorityElement()) 8286 composeEnum(t, "MedicationRequest", "priority", element.getPriorityElement(), -1); 8287 if (element.hasMedication()) 8288 composeType(t, "MedicationRequest", "medication", element.getMedication(), -1); 8289 if (element.hasSubject()) 8290 composeReference(t, "MedicationRequest", "subject", element.getSubject(), -1); 8291 if (element.hasContext()) 8292 composeReference(t, "MedicationRequest", "context", element.getContext(), -1); 8293 for (int i = 0; i < element.getSupportingInformation().size(); i++) 8294 composeReference(t, "MedicationRequest", "supportingInformation", element.getSupportingInformation().get(i), i); 8295 if (element.hasAuthoredOnElement()) 8296 composeDateTime(t, "MedicationRequest", "authoredOn", element.getAuthoredOnElement(), -1); 8297 if (element.hasRequester()) 8298 composeMedicationRequestMedicationRequestRequesterComponent(t, "MedicationRequest", "requester", element.getRequester(), -1); 8299 if (element.hasRecorder()) 8300 composeReference(t, "MedicationRequest", "recorder", element.getRecorder(), -1); 8301 for (int i = 0; i < element.getReasonCode().size(); i++) 8302 composeCodeableConcept(t, "MedicationRequest", "reasonCode", element.getReasonCode().get(i), i); 8303 for (int i = 0; i < element.getReasonReference().size(); i++) 8304 composeReference(t, "MedicationRequest", "reasonReference", element.getReasonReference().get(i), i); 8305 for (int i = 0; i < element.getNote().size(); i++) 8306 composeAnnotation(t, "MedicationRequest", "note", element.getNote().get(i), i); 8307 for (int i = 0; i < element.getDosageInstruction().size(); i++) 8308 composeDosage(t, "MedicationRequest", "dosageInstruction", element.getDosageInstruction().get(i), i); 8309 if (element.hasDispenseRequest()) 8310 composeMedicationRequestMedicationRequestDispenseRequestComponent(t, "MedicationRequest", "dispenseRequest", element.getDispenseRequest(), -1); 8311 if (element.hasSubstitution()) 8312 composeMedicationRequestMedicationRequestSubstitutionComponent(t, "MedicationRequest", "substitution", element.getSubstitution(), -1); 8313 if (element.hasPriorPrescription()) 8314 composeReference(t, "MedicationRequest", "priorPrescription", element.getPriorPrescription(), -1); 8315 for (int i = 0; i < element.getDetectedIssue().size(); i++) 8316 composeReference(t, "MedicationRequest", "detectedIssue", element.getDetectedIssue().get(i), i); 8317 for (int i = 0; i < element.getEventHistory().size(); i++) 8318 composeReference(t, "MedicationRequest", "eventHistory", element.getEventHistory().get(i), i); 8319 } 8320 8321 protected void composeMedicationRequestMedicationRequestRequesterComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestRequesterComponent element, int index) { 8322 if (element == null) 8323 return; 8324 Complex t; 8325 if (Utilities.noString(parentType)) 8326 t = parent; 8327 else { 8328 t = parent.predicate("fhir:"+parentType+'.'+name); 8329 } 8330 composeBackboneElement(t, "requester", name, element, index); 8331 if (element.hasAgent()) 8332 composeReference(t, "MedicationRequest", "agent", element.getAgent(), -1); 8333 if (element.hasOnBehalfOf()) 8334 composeReference(t, "MedicationRequest", "onBehalfOf", element.getOnBehalfOf(), -1); 8335 } 8336 8337 protected void composeMedicationRequestMedicationRequestDispenseRequestComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestDispenseRequestComponent element, int index) { 8338 if (element == null) 8339 return; 8340 Complex t; 8341 if (Utilities.noString(parentType)) 8342 t = parent; 8343 else { 8344 t = parent.predicate("fhir:"+parentType+'.'+name); 8345 } 8346 composeBackboneElement(t, "dispenseRequest", name, element, index); 8347 if (element.hasValidityPeriod()) 8348 composePeriod(t, "MedicationRequest", "validityPeriod", element.getValidityPeriod(), -1); 8349 if (element.hasNumberOfRepeatsAllowedElement()) 8350 composePositiveInt(t, "MedicationRequest", "numberOfRepeatsAllowed", element.getNumberOfRepeatsAllowedElement(), -1); 8351 if (element.hasQuantity()) 8352 composeQuantity(t, "MedicationRequest", "quantity", element.getQuantity(), -1); 8353 if (element.hasExpectedSupplyDuration()) 8354 composeDuration(t, "MedicationRequest", "expectedSupplyDuration", element.getExpectedSupplyDuration(), -1); 8355 if (element.hasPerformer()) 8356 composeReference(t, "MedicationRequest", "performer", element.getPerformer(), -1); 8357 } 8358 8359 protected void composeMedicationRequestMedicationRequestSubstitutionComponent(Complex parent, String parentType, String name, MedicationRequest.MedicationRequestSubstitutionComponent element, int index) { 8360 if (element == null) 8361 return; 8362 Complex t; 8363 if (Utilities.noString(parentType)) 8364 t = parent; 8365 else { 8366 t = parent.predicate("fhir:"+parentType+'.'+name); 8367 } 8368 composeBackboneElement(t, "substitution", name, element, index); 8369 if (element.hasAllowedElement()) 8370 composeBoolean(t, "MedicationRequest", "allowed", element.getAllowedElement(), -1); 8371 if (element.hasReason()) 8372 composeCodeableConcept(t, "MedicationRequest", "reason", element.getReason(), -1); 8373 } 8374 8375 protected void composeMedicationStatement(Complex parent, String parentType, String name, MedicationStatement element, int index) { 8376 if (element == null) 8377 return; 8378 Complex t; 8379 if (Utilities.noString(parentType)) 8380 t = parent; 8381 else { 8382 t = parent.predicate("fhir:"+parentType+'.'+name); 8383 } 8384 composeDomainResource(t, "MedicationStatement", name, element, index); 8385 for (int i = 0; i < element.getIdentifier().size(); i++) 8386 composeIdentifier(t, "MedicationStatement", "identifier", element.getIdentifier().get(i), i); 8387 for (int i = 0; i < element.getBasedOn().size(); i++) 8388 composeReference(t, "MedicationStatement", "basedOn", element.getBasedOn().get(i), i); 8389 for (int i = 0; i < element.getPartOf().size(); i++) 8390 composeReference(t, "MedicationStatement", "partOf", element.getPartOf().get(i), i); 8391 if (element.hasContext()) 8392 composeReference(t, "MedicationStatement", "context", element.getContext(), -1); 8393 if (element.hasStatusElement()) 8394 composeEnum(t, "MedicationStatement", "status", element.getStatusElement(), -1); 8395 if (element.hasCategory()) 8396 composeCodeableConcept(t, "MedicationStatement", "category", element.getCategory(), -1); 8397 if (element.hasMedication()) 8398 composeType(t, "MedicationStatement", "medication", element.getMedication(), -1); 8399 if (element.hasEffective()) 8400 composeType(t, "MedicationStatement", "effective", element.getEffective(), -1); 8401 if (element.hasDateAssertedElement()) 8402 composeDateTime(t, "MedicationStatement", "dateAsserted", element.getDateAssertedElement(), -1); 8403 if (element.hasInformationSource()) 8404 composeReference(t, "MedicationStatement", "informationSource", element.getInformationSource(), -1); 8405 if (element.hasSubject()) 8406 composeReference(t, "MedicationStatement", "subject", element.getSubject(), -1); 8407 for (int i = 0; i < element.getDerivedFrom().size(); i++) 8408 composeReference(t, "MedicationStatement", "derivedFrom", element.getDerivedFrom().get(i), i); 8409 if (element.hasTakenElement()) 8410 composeEnum(t, "MedicationStatement", "taken", element.getTakenElement(), -1); 8411 for (int i = 0; i < element.getReasonNotTaken().size(); i++) 8412 composeCodeableConcept(t, "MedicationStatement", "reasonNotTaken", element.getReasonNotTaken().get(i), i); 8413 for (int i = 0; i < element.getReasonCode().size(); i++) 8414 composeCodeableConcept(t, "MedicationStatement", "reasonCode", element.getReasonCode().get(i), i); 8415 for (int i = 0; i < element.getReasonReference().size(); i++) 8416 composeReference(t, "MedicationStatement", "reasonReference", element.getReasonReference().get(i), i); 8417 for (int i = 0; i < element.getNote().size(); i++) 8418 composeAnnotation(t, "MedicationStatement", "note", element.getNote().get(i), i); 8419 for (int i = 0; i < element.getDosage().size(); i++) 8420 composeDosage(t, "MedicationStatement", "dosage", element.getDosage().get(i), i); 8421 } 8422 8423 protected void composeMessageDefinition(Complex parent, String parentType, String name, MessageDefinition element, int index) { 8424 if (element == null) 8425 return; 8426 Complex t; 8427 if (Utilities.noString(parentType)) 8428 t = parent; 8429 else { 8430 t = parent.predicate("fhir:"+parentType+'.'+name); 8431 } 8432 composeDomainResource(t, "MessageDefinition", name, element, index); 8433 if (element.hasUrlElement()) 8434 composeUri(t, "MessageDefinition", "url", element.getUrlElement(), -1); 8435 if (element.hasIdentifier()) 8436 composeIdentifier(t, "MessageDefinition", "identifier", element.getIdentifier(), -1); 8437 if (element.hasVersionElement()) 8438 composeString(t, "MessageDefinition", "version", element.getVersionElement(), -1); 8439 if (element.hasNameElement()) 8440 composeString(t, "MessageDefinition", "name", element.getNameElement(), -1); 8441 if (element.hasTitleElement()) 8442 composeString(t, "MessageDefinition", "title", element.getTitleElement(), -1); 8443 if (element.hasStatusElement()) 8444 composeEnum(t, "MessageDefinition", "status", element.getStatusElement(), -1); 8445 if (element.hasExperimentalElement()) 8446 composeBoolean(t, "MessageDefinition", "experimental", element.getExperimentalElement(), -1); 8447 if (element.hasDateElement()) 8448 composeDateTime(t, "MessageDefinition", "date", element.getDateElement(), -1); 8449 if (element.hasPublisherElement()) 8450 composeString(t, "MessageDefinition", "publisher", element.getPublisherElement(), -1); 8451 for (int i = 0; i < element.getContact().size(); i++) 8452 composeContactDetail(t, "MessageDefinition", "contact", element.getContact().get(i), i); 8453 if (element.hasDescriptionElement()) 8454 composeMarkdown(t, "MessageDefinition", "description", element.getDescriptionElement(), -1); 8455 for (int i = 0; i < element.getUseContext().size(); i++) 8456 composeUsageContext(t, "MessageDefinition", "useContext", element.getUseContext().get(i), i); 8457 for (int i = 0; i < element.getJurisdiction().size(); i++) 8458 composeCodeableConcept(t, "MessageDefinition", "jurisdiction", element.getJurisdiction().get(i), i); 8459 if (element.hasPurposeElement()) 8460 composeMarkdown(t, "MessageDefinition", "purpose", element.getPurposeElement(), -1); 8461 if (element.hasCopyrightElement()) 8462 composeMarkdown(t, "MessageDefinition", "copyright", element.getCopyrightElement(), -1); 8463 if (element.hasBase()) 8464 composeReference(t, "MessageDefinition", "base", element.getBase(), -1); 8465 for (int i = 0; i < element.getParent().size(); i++) 8466 composeReference(t, "MessageDefinition", "parent", element.getParent().get(i), i); 8467 for (int i = 0; i < element.getReplaces().size(); i++) 8468 composeReference(t, "MessageDefinition", "replaces", element.getReplaces().get(i), i); 8469 if (element.hasEvent()) 8470 composeCoding(t, "MessageDefinition", "event", element.getEvent(), -1); 8471 if (element.hasCategoryElement()) 8472 composeEnum(t, "MessageDefinition", "category", element.getCategoryElement(), -1); 8473 for (int i = 0; i < element.getFocus().size(); i++) 8474 composeMessageDefinitionMessageDefinitionFocusComponent(t, "MessageDefinition", "focus", element.getFocus().get(i), i); 8475 if (element.hasResponseRequiredElement()) 8476 composeBoolean(t, "MessageDefinition", "responseRequired", element.getResponseRequiredElement(), -1); 8477 for (int i = 0; i < element.getAllowedResponse().size(); i++) 8478 composeMessageDefinitionMessageDefinitionAllowedResponseComponent(t, "MessageDefinition", "allowedResponse", element.getAllowedResponse().get(i), i); 8479 } 8480 8481 protected void composeMessageDefinitionMessageDefinitionFocusComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionFocusComponent element, int index) { 8482 if (element == null) 8483 return; 8484 Complex t; 8485 if (Utilities.noString(parentType)) 8486 t = parent; 8487 else { 8488 t = parent.predicate("fhir:"+parentType+'.'+name); 8489 } 8490 composeBackboneElement(t, "focus", name, element, index); 8491 if (element.hasCodeElement()) 8492 composeCode(t, "MessageDefinition", "code", element.getCodeElement(), -1); 8493 if (element.hasProfile()) 8494 composeReference(t, "MessageDefinition", "profile", element.getProfile(), -1); 8495 if (element.hasMinElement()) 8496 composeUnsignedInt(t, "MessageDefinition", "min", element.getMinElement(), -1); 8497 if (element.hasMaxElement()) 8498 composeString(t, "MessageDefinition", "max", element.getMaxElement(), -1); 8499 } 8500 8501 protected void composeMessageDefinitionMessageDefinitionAllowedResponseComponent(Complex parent, String parentType, String name, MessageDefinition.MessageDefinitionAllowedResponseComponent element, int index) { 8502 if (element == null) 8503 return; 8504 Complex t; 8505 if (Utilities.noString(parentType)) 8506 t = parent; 8507 else { 8508 t = parent.predicate("fhir:"+parentType+'.'+name); 8509 } 8510 composeBackboneElement(t, "allowedResponse", name, element, index); 8511 if (element.hasMessage()) 8512 composeReference(t, "MessageDefinition", "message", element.getMessage(), -1); 8513 if (element.hasSituationElement()) 8514 composeMarkdown(t, "MessageDefinition", "situation", element.getSituationElement(), -1); 8515 } 8516 8517 protected void composeMessageHeader(Complex parent, String parentType, String name, MessageHeader element, int index) { 8518 if (element == null) 8519 return; 8520 Complex t; 8521 if (Utilities.noString(parentType)) 8522 t = parent; 8523 else { 8524 t = parent.predicate("fhir:"+parentType+'.'+name); 8525 } 8526 composeDomainResource(t, "MessageHeader", name, element, index); 8527 if (element.hasEvent()) 8528 composeCoding(t, "MessageHeader", "event", element.getEvent(), -1); 8529 for (int i = 0; i < element.getDestination().size(); i++) 8530 composeMessageHeaderMessageDestinationComponent(t, "MessageHeader", "destination", element.getDestination().get(i), i); 8531 if (element.hasReceiver()) 8532 composeReference(t, "MessageHeader", "receiver", element.getReceiver(), -1); 8533 if (element.hasSender()) 8534 composeReference(t, "MessageHeader", "sender", element.getSender(), -1); 8535 if (element.hasTimestampElement()) 8536 composeInstant(t, "MessageHeader", "timestamp", element.getTimestampElement(), -1); 8537 if (element.hasEnterer()) 8538 composeReference(t, "MessageHeader", "enterer", element.getEnterer(), -1); 8539 if (element.hasAuthor()) 8540 composeReference(t, "MessageHeader", "author", element.getAuthor(), -1); 8541 if (element.hasSource()) 8542 composeMessageHeaderMessageSourceComponent(t, "MessageHeader", "source", element.getSource(), -1); 8543 if (element.hasResponsible()) 8544 composeReference(t, "MessageHeader", "responsible", element.getResponsible(), -1); 8545 if (element.hasReason()) 8546 composeCodeableConcept(t, "MessageHeader", "reason", element.getReason(), -1); 8547 if (element.hasResponse()) 8548 composeMessageHeaderMessageHeaderResponseComponent(t, "MessageHeader", "response", element.getResponse(), -1); 8549 for (int i = 0; i < element.getFocus().size(); i++) 8550 composeReference(t, "MessageHeader", "focus", element.getFocus().get(i), i); 8551 } 8552 8553 protected void composeMessageHeaderMessageDestinationComponent(Complex parent, String parentType, String name, MessageHeader.MessageDestinationComponent element, int index) { 8554 if (element == null) 8555 return; 8556 Complex t; 8557 if (Utilities.noString(parentType)) 8558 t = parent; 8559 else { 8560 t = parent.predicate("fhir:"+parentType+'.'+name); 8561 } 8562 composeBackboneElement(t, "destination", name, element, index); 8563 if (element.hasNameElement()) 8564 composeString(t, "MessageHeader", "name", element.getNameElement(), -1); 8565 if (element.hasTarget()) 8566 composeReference(t, "MessageHeader", "target", element.getTarget(), -1); 8567 if (element.hasEndpointElement()) 8568 composeUri(t, "MessageHeader", "endpoint", element.getEndpointElement(), -1); 8569 } 8570 8571 protected void composeMessageHeaderMessageSourceComponent(Complex parent, String parentType, String name, MessageHeader.MessageSourceComponent element, int index) { 8572 if (element == null) 8573 return; 8574 Complex t; 8575 if (Utilities.noString(parentType)) 8576 t = parent; 8577 else { 8578 t = parent.predicate("fhir:"+parentType+'.'+name); 8579 } 8580 composeBackboneElement(t, "source", name, element, index); 8581 if (element.hasNameElement()) 8582 composeString(t, "MessageHeader", "name", element.getNameElement(), -1); 8583 if (element.hasSoftwareElement()) 8584 composeString(t, "MessageHeader", "software", element.getSoftwareElement(), -1); 8585 if (element.hasVersionElement()) 8586 composeString(t, "MessageHeader", "version", element.getVersionElement(), -1); 8587 if (element.hasContact()) 8588 composeContactPoint(t, "MessageHeader", "contact", element.getContact(), -1); 8589 if (element.hasEndpointElement()) 8590 composeUri(t, "MessageHeader", "endpoint", element.getEndpointElement(), -1); 8591 } 8592 8593 protected void composeMessageHeaderMessageHeaderResponseComponent(Complex parent, String parentType, String name, MessageHeader.MessageHeaderResponseComponent element, int index) { 8594 if (element == null) 8595 return; 8596 Complex t; 8597 if (Utilities.noString(parentType)) 8598 t = parent; 8599 else { 8600 t = parent.predicate("fhir:"+parentType+'.'+name); 8601 } 8602 composeBackboneElement(t, "response", name, element, index); 8603 if (element.hasIdentifierElement()) 8604 composeId(t, "MessageHeader", "identifier", element.getIdentifierElement(), -1); 8605 if (element.hasCodeElement()) 8606 composeEnum(t, "MessageHeader", "code", element.getCodeElement(), -1); 8607 if (element.hasDetails()) 8608 composeReference(t, "MessageHeader", "details", element.getDetails(), -1); 8609 } 8610 8611 protected void composeNamingSystem(Complex parent, String parentType, String name, NamingSystem element, int index) { 8612 if (element == null) 8613 return; 8614 Complex t; 8615 if (Utilities.noString(parentType)) 8616 t = parent; 8617 else { 8618 t = parent.predicate("fhir:"+parentType+'.'+name); 8619 } 8620 composeDomainResource(t, "NamingSystem", name, element, index); 8621 if (element.hasNameElement()) 8622 composeString(t, "NamingSystem", "name", element.getNameElement(), -1); 8623 if (element.hasStatusElement()) 8624 composeEnum(t, "NamingSystem", "status", element.getStatusElement(), -1); 8625 if (element.hasKindElement()) 8626 composeEnum(t, "NamingSystem", "kind", element.getKindElement(), -1); 8627 if (element.hasDateElement()) 8628 composeDateTime(t, "NamingSystem", "date", element.getDateElement(), -1); 8629 if (element.hasPublisherElement()) 8630 composeString(t, "NamingSystem", "publisher", element.getPublisherElement(), -1); 8631 for (int i = 0; i < element.getContact().size(); i++) 8632 composeContactDetail(t, "NamingSystem", "contact", element.getContact().get(i), i); 8633 if (element.hasResponsibleElement()) 8634 composeString(t, "NamingSystem", "responsible", element.getResponsibleElement(), -1); 8635 if (element.hasType()) 8636 composeCodeableConcept(t, "NamingSystem", "type", element.getType(), -1); 8637 if (element.hasDescriptionElement()) 8638 composeMarkdown(t, "NamingSystem", "description", element.getDescriptionElement(), -1); 8639 for (int i = 0; i < element.getUseContext().size(); i++) 8640 composeUsageContext(t, "NamingSystem", "useContext", element.getUseContext().get(i), i); 8641 for (int i = 0; i < element.getJurisdiction().size(); i++) 8642 composeCodeableConcept(t, "NamingSystem", "jurisdiction", element.getJurisdiction().get(i), i); 8643 if (element.hasUsageElement()) 8644 composeString(t, "NamingSystem", "usage", element.getUsageElement(), -1); 8645 for (int i = 0; i < element.getUniqueId().size(); i++) 8646 composeNamingSystemNamingSystemUniqueIdComponent(t, "NamingSystem", "uniqueId", element.getUniqueId().get(i), i); 8647 if (element.hasReplacedBy()) 8648 composeReference(t, "NamingSystem", "replacedBy", element.getReplacedBy(), -1); 8649 } 8650 8651 protected void composeNamingSystemNamingSystemUniqueIdComponent(Complex parent, String parentType, String name, NamingSystem.NamingSystemUniqueIdComponent element, int index) { 8652 if (element == null) 8653 return; 8654 Complex t; 8655 if (Utilities.noString(parentType)) 8656 t = parent; 8657 else { 8658 t = parent.predicate("fhir:"+parentType+'.'+name); 8659 } 8660 composeBackboneElement(t, "uniqueId", name, element, index); 8661 if (element.hasTypeElement()) 8662 composeEnum(t, "NamingSystem", "type", element.getTypeElement(), -1); 8663 if (element.hasValueElement()) 8664 composeString(t, "NamingSystem", "value", element.getValueElement(), -1); 8665 if (element.hasPreferredElement()) 8666 composeBoolean(t, "NamingSystem", "preferred", element.getPreferredElement(), -1); 8667 if (element.hasCommentElement()) 8668 composeString(t, "NamingSystem", "comment", element.getCommentElement(), -1); 8669 if (element.hasPeriod()) 8670 composePeriod(t, "NamingSystem", "period", element.getPeriod(), -1); 8671 } 8672 8673 protected void composeNutritionOrder(Complex parent, String parentType, String name, NutritionOrder element, int index) { 8674 if (element == null) 8675 return; 8676 Complex t; 8677 if (Utilities.noString(parentType)) 8678 t = parent; 8679 else { 8680 t = parent.predicate("fhir:"+parentType+'.'+name); 8681 } 8682 composeDomainResource(t, "NutritionOrder", name, element, index); 8683 for (int i = 0; i < element.getIdentifier().size(); i++) 8684 composeIdentifier(t, "NutritionOrder", "identifier", element.getIdentifier().get(i), i); 8685 if (element.hasStatusElement()) 8686 composeEnum(t, "NutritionOrder", "status", element.getStatusElement(), -1); 8687 if (element.hasPatient()) 8688 composeReference(t, "NutritionOrder", "patient", element.getPatient(), -1); 8689 if (element.hasEncounter()) 8690 composeReference(t, "NutritionOrder", "encounter", element.getEncounter(), -1); 8691 if (element.hasDateTimeElement()) 8692 composeDateTime(t, "NutritionOrder", "dateTime", element.getDateTimeElement(), -1); 8693 if (element.hasOrderer()) 8694 composeReference(t, "NutritionOrder", "orderer", element.getOrderer(), -1); 8695 for (int i = 0; i < element.getAllergyIntolerance().size(); i++) 8696 composeReference(t, "NutritionOrder", "allergyIntolerance", element.getAllergyIntolerance().get(i), i); 8697 for (int i = 0; i < element.getFoodPreferenceModifier().size(); i++) 8698 composeCodeableConcept(t, "NutritionOrder", "foodPreferenceModifier", element.getFoodPreferenceModifier().get(i), i); 8699 for (int i = 0; i < element.getExcludeFoodModifier().size(); i++) 8700 composeCodeableConcept(t, "NutritionOrder", "excludeFoodModifier", element.getExcludeFoodModifier().get(i), i); 8701 if (element.hasOralDiet()) 8702 composeNutritionOrderNutritionOrderOralDietComponent(t, "NutritionOrder", "oralDiet", element.getOralDiet(), -1); 8703 for (int i = 0; i < element.getSupplement().size(); i++) 8704 composeNutritionOrderNutritionOrderSupplementComponent(t, "NutritionOrder", "supplement", element.getSupplement().get(i), i); 8705 if (element.hasEnteralFormula()) 8706 composeNutritionOrderNutritionOrderEnteralFormulaComponent(t, "NutritionOrder", "enteralFormula", element.getEnteralFormula(), -1); 8707 } 8708 8709 protected void composeNutritionOrderNutritionOrderOralDietComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietComponent element, int index) { 8710 if (element == null) 8711 return; 8712 Complex t; 8713 if (Utilities.noString(parentType)) 8714 t = parent; 8715 else { 8716 t = parent.predicate("fhir:"+parentType+'.'+name); 8717 } 8718 composeBackboneElement(t, "oralDiet", name, element, index); 8719 for (int i = 0; i < element.getType().size(); i++) 8720 composeCodeableConcept(t, "NutritionOrder", "type", element.getType().get(i), i); 8721 for (int i = 0; i < element.getSchedule().size(); i++) 8722 composeTiming(t, "NutritionOrder", "schedule", element.getSchedule().get(i), i); 8723 for (int i = 0; i < element.getNutrient().size(); i++) 8724 composeNutritionOrderNutritionOrderOralDietNutrientComponent(t, "NutritionOrder", "nutrient", element.getNutrient().get(i), i); 8725 for (int i = 0; i < element.getTexture().size(); i++) 8726 composeNutritionOrderNutritionOrderOralDietTextureComponent(t, "NutritionOrder", "texture", element.getTexture().get(i), i); 8727 for (int i = 0; i < element.getFluidConsistencyType().size(); i++) 8728 composeCodeableConcept(t, "NutritionOrder", "fluidConsistencyType", element.getFluidConsistencyType().get(i), i); 8729 if (element.hasInstructionElement()) 8730 composeString(t, "NutritionOrder", "instruction", element.getInstructionElement(), -1); 8731 } 8732 8733 protected void composeNutritionOrderNutritionOrderOralDietNutrientComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietNutrientComponent element, int index) { 8734 if (element == null) 8735 return; 8736 Complex t; 8737 if (Utilities.noString(parentType)) 8738 t = parent; 8739 else { 8740 t = parent.predicate("fhir:"+parentType+'.'+name); 8741 } 8742 composeBackboneElement(t, "nutrient", name, element, index); 8743 if (element.hasModifier()) 8744 composeCodeableConcept(t, "NutritionOrder", "modifier", element.getModifier(), -1); 8745 if (element.hasAmount()) 8746 composeQuantity(t, "NutritionOrder", "amount", element.getAmount(), -1); 8747 } 8748 8749 protected void composeNutritionOrderNutritionOrderOralDietTextureComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietTextureComponent element, int index) { 8750 if (element == null) 8751 return; 8752 Complex t; 8753 if (Utilities.noString(parentType)) 8754 t = parent; 8755 else { 8756 t = parent.predicate("fhir:"+parentType+'.'+name); 8757 } 8758 composeBackboneElement(t, "texture", name, element, index); 8759 if (element.hasModifier()) 8760 composeCodeableConcept(t, "NutritionOrder", "modifier", element.getModifier(), -1); 8761 if (element.hasFoodType()) 8762 composeCodeableConcept(t, "NutritionOrder", "foodType", element.getFoodType(), -1); 8763 } 8764 8765 protected void composeNutritionOrderNutritionOrderSupplementComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderSupplementComponent element, int index) { 8766 if (element == null) 8767 return; 8768 Complex t; 8769 if (Utilities.noString(parentType)) 8770 t = parent; 8771 else { 8772