001package org.hl7.fhir.dstu2016may.formats; 002 003 004 005 006import org.hl7.fhir.dstu2016may.formats.RdfGenerator.Complex; 007 008/* 009 Copyright (c) 2011+, HL7, Inc. 010 All rights reserved. 011 012 Redistribution and use in source and binary forms, with or without modification, 013 are permitted provided that the following conditions are met: 014 015 * Redistributions of source code must retain the above copyright notice, this 016 list of conditions and the following disclaimer. 017 * Redistributions in binary form must reproduce the above copyright notice, 018 this list of conditions and the following disclaimer in the documentation 019 and/or other materials provided with the distribution. 020 * Neither the name of HL7 nor the names of its contributors may be used to 021 endorse or promote products derived from this software without specific 022 prior written permission. 023 024 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 025 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 026 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 027 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 028 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 029 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 030 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 031 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 032 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 033 POSSIBILITY OF SUCH DAMAGE. 034 035*/ 036 037// Generated on Sun, May 8, 2016 03:05+1000 for FHIR v1.4.0 038import org.hl7.fhir.dstu2016may.model.*; 039import org.hl7.fhir.utilities.Utilities; 040 041public class RdfParser extends RdfParserBase { 042 043 public RdfParser() { 044 super(); 045 } 046 047 public RdfParser(boolean allowUnknownContent) { 048 super(); 049 setAllowUnknownContent(allowUnknownContent); 050 } 051 052 053 protected void composeElement(Complex t, String parentType, String name, Element element, int index) { 054 if (element == null) 055 return; 056 if (index > -1) 057 t.predicate("fhir:index", Integer.toString(index)); 058 if (element.hasIdElement()) 059 composeId(t, "Element", "id", element.getIdElement(), -1); 060 for (int i = 0; i < element.getExtension().size(); i++) 061 composeExtension(t, "Element", "extension", element.getExtension().get(i), i); 062 } 063 064 protected void composeBackboneElement(Complex t, String tType, String name, BackboneElement element, int index) { 065 composeElement(t, tType, name, element, index); 066 for (int i = 0; i < element.getModifierExtension().size(); i++) 067 composeExtension(t, "Element", "modifierExtension", element.getModifierExtension().get(i), i); 068 } 069 070 private void composeEnum(Complex parent, String parentType, String name, Enumeration<? extends Enum> value, int index) { 071 if (value == null) 072 return; 073 Complex t = parent.predicate("fhir:"+parentType+"."+name); 074 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 075 composeElement(t, parentType, name, value, index); 076 decorateCode(t, value); 077 } 078 079 080 protected void composeMarkdown(Complex parent, String parentType, String name, MarkdownType value, int index) { 081 if (value == null) 082 return; 083 Complex t = parent.predicate("fhir:"+parentType+"."+name); 084 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 085 composeElement(t, parentType, name, value, index); 086 } 087 088 protected void composeInteger(Complex parent, String parentType, String name, IntegerType value, int index) { 089 if (value == null) 090 return; 091 Complex t = parent.predicate("fhir:"+parentType+"."+name); 092 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 093 composeElement(t, parentType, name, value, index); 094 } 095 096 protected void composeDateTime(Complex parent, String parentType, String name, DateTimeType value, int index) { 097 if (value == null) 098 return; 099 Complex t = parent.predicate("fhir:"+parentType+"."+name); 100 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 101 composeElement(t, parentType, name, value, index); 102 } 103 104 protected void composeUnsignedInt(Complex parent, String parentType, String name, UnsignedIntType 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 composeCode(Complex parent, String parentType, String name, CodeType 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 decorateCode(t, value); 119 } 120 121 protected void composeDate(Complex parent, String parentType, String name, DateType value, int index) { 122 if (value == null) 123 return; 124 Complex t = parent.predicate("fhir:"+parentType+"."+name); 125 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 126 composeElement(t, parentType, name, value, index); 127 } 128 129 protected void composeDecimal(Complex parent, String parentType, String name, DecimalType value, int index) { 130 if (value == null) 131 return; 132 Complex t = parent.predicate("fhir:"+parentType+"."+name); 133 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 134 composeElement(t, parentType, name, value, index); 135 } 136 137 protected void composeUri(Complex parent, String parentType, String name, UriType value, int index) { 138 if (value == null) 139 return; 140 Complex t = parent.predicate("fhir:"+parentType+"."+name); 141 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 142 composeElement(t, parentType, name, value, index); 143 } 144 145 protected void composeId(Complex parent, String parentType, String name, IdType value, int index) { 146 if (value == null) 147 return; 148 Complex t = parent.predicate("fhir:"+parentType+"."+name); 149 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 150 composeElement(t, parentType, name, value, index); 151 } 152 153 protected void composeBase64Binary(Complex parent, String parentType, String name, Base64BinaryType value, int index) { 154 if (value == null) 155 return; 156 Complex t = parent.predicate("fhir:"+parentType+"."+name); 157 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 158 composeElement(t, parentType, name, value, index); 159 } 160 161 protected void composeTime(Complex parent, String parentType, String name, TimeType value, int index) { 162 if (value == null) 163 return; 164 Complex t = parent.predicate("fhir:"+parentType+"."+name); 165 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 166 composeElement(t, parentType, name, value, index); 167 } 168 169 protected void composeOid(Complex parent, String parentType, String name, OidType value, int index) { 170 if (value == null) 171 return; 172 Complex t = parent.predicate("fhir:"+parentType+"."+name); 173 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 174 composeElement(t, parentType, name, value, index); 175 } 176 177 protected void composePositiveInt(Complex parent, String parentType, String name, PositiveIntType value, int index) { 178 if (value == null) 179 return; 180 Complex t = parent.predicate("fhir:"+parentType+"."+name); 181 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 182 composeElement(t, parentType, name, value, index); 183 } 184 185 protected void composeString(Complex parent, String parentType, String name, StringType value, int index) { 186 if (value == null) 187 return; 188 Complex t = parent.predicate("fhir:"+parentType+"."+name); 189 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 190 composeElement(t, parentType, name, value, index); 191 } 192 193 protected void composeBoolean(Complex parent, String parentType, String name, BooleanType value, int index) { 194 if (value == null) 195 return; 196 Complex t = parent.predicate("fhir:"+parentType+"."+name); 197 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 198 composeElement(t, parentType, name, value, index); 199 } 200 201 protected void composeUuid(Complex parent, String parentType, String name, UuidType value, int index) { 202 if (value == null) 203 return; 204 Complex t = parent.predicate("fhir:"+parentType+"."+name); 205 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 206 composeElement(t, parentType, name, value, index); 207 } 208 209 protected void composeInstant(Complex parent, String parentType, String name, InstantType value, int index) { 210 if (value == null) 211 return; 212 Complex t = parent.predicate("fhir:"+parentType+"."+name); 213 t.predicate("fhir:value", ttlLiteral(value.asStringValue())); 214 composeElement(t, parentType, name, value, index); 215 } 216 217 protected void composeExtension(Complex parent, String parentType, String name, Extension element, int index) { 218 if (element == null) 219 return; 220 Complex t; 221 if (Utilities.noString(parentType)) 222 t = parent; 223 else { 224 t = parent.predicate("fhir:"+parentType+'.'+name); 225 } 226 composeElement(t, "Extension", name, element, index); 227 if (element.hasUrlElement()) 228 composeUri(t, "Extension", "url", element.getUrlElement(), -1); 229 if (element.hasValue()) 230 composeType(t, "Extension", "value", element.getValue(), -1); 231 } 232 233 protected void composeNarrative(Complex parent, String parentType, String name, Narrative element, int index) { 234 if (element == null) 235 return; 236 Complex t; 237 if (Utilities.noString(parentType)) 238 t = parent; 239 else { 240 t = parent.predicate("fhir:"+parentType+'.'+name); 241 } 242 composeElement(t, "Narrative", name, element, index); 243 if (element.hasStatusElement()) 244 composeEnum(t, "Narrative", "status", element.getStatusElement(), -1); 245 if (element.hasDiv()) 246 composeXhtml(t, "Narrative", "div", element.getDiv(), -1); 247 } 248 249 protected void composePeriod(Complex parent, String parentType, String name, Period element, int index) { 250 if (element == null) 251 return; 252 Complex t; 253 if (Utilities.noString(parentType)) 254 t = parent; 255 else { 256 t = parent.predicate("fhir:"+parentType+'.'+name); 257 } 258 composeElement(t, "Period", name, element, index); 259 if (element.hasStartElement()) 260 composeDateTime(t, "Period", "start", element.getStartElement(), -1); 261 if (element.hasEndElement()) 262 composeDateTime(t, "Period", "end", element.getEndElement(), -1); 263 } 264 265 protected void composeCoding(Complex parent, String parentType, String name, Coding element, int index) { 266 if (element == null) 267 return; 268 Complex t; 269 if (Utilities.noString(parentType)) 270 t = parent; 271 else { 272 t = parent.predicate("fhir:"+parentType+'.'+name); 273 } 274 composeElement(t, "Coding", name, element, index); 275 decorateCoding(t, element); 276 if (element.hasSystemElement()) 277 composeUri(t, "Coding", "system", element.getSystemElement(), -1); 278 if (element.hasVersionElement()) 279 composeString(t, "Coding", "version", element.getVersionElement(), -1); 280 if (element.hasCodeElement()) 281 composeCode(t, "Coding", "code", element.getCodeElement(), -1); 282 if (element.hasDisplayElement()) 283 composeString(t, "Coding", "display", element.getDisplayElement(), -1); 284 if (element.hasUserSelectedElement()) 285 composeBoolean(t, "Coding", "userSelected", element.getUserSelectedElement(), -1); 286 } 287 288 protected void composeRange(Complex parent, String parentType, String name, Range 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, "Range", name, element, index); 298 if (element.hasLow()) 299 composeQuantity(t, "Range", "low", element.getLow(), -1); 300 if (element.hasHigh()) 301 composeQuantity(t, "Range", "high", element.getHigh(), -1); 302 } 303 304 protected void composeQuantity(Complex parent, String parentType, String name, Quantity 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, "Quantity", name, element, index); 314 if (element.hasValueElement()) 315 composeDecimal(t, "Quantity", "value", element.getValueElement(), -1); 316 if (element.hasComparatorElement()) 317 composeEnum(t, "Quantity", "comparator", element.getComparatorElement(), -1); 318 if (element.hasUnitElement()) 319 composeString(t, "Quantity", "unit", element.getUnitElement(), -1); 320 if (element.hasSystemElement()) 321 composeUri(t, "Quantity", "system", element.getSystemElement(), -1); 322 if (element.hasCodeElement()) 323 composeCode(t, "Quantity", "code", element.getCodeElement(), -1); 324 } 325 326 protected void composeAttachment(Complex parent, String parentType, String name, Attachment element, int index) { 327 if (element == null) 328 return; 329 Complex t; 330 if (Utilities.noString(parentType)) 331 t = parent; 332 else { 333 t = parent.predicate("fhir:"+parentType+'.'+name); 334 } 335 composeElement(t, "Attachment", name, element, index); 336 if (element.hasContentTypeElement()) 337 composeCode(t, "Attachment", "contentType", element.getContentTypeElement(), -1); 338 if (element.hasLanguageElement()) 339 composeCode(t, "Attachment", "language", element.getLanguageElement(), -1); 340 if (element.hasDataElement()) 341 composeBase64Binary(t, "Attachment", "data", element.getDataElement(), -1); 342 if (element.hasUrlElement()) 343 composeUri(t, "Attachment", "url", element.getUrlElement(), -1); 344 if (element.hasSizeElement()) 345 composeUnsignedInt(t, "Attachment", "size", element.getSizeElement(), -1); 346 if (element.hasHashElement()) 347 composeBase64Binary(t, "Attachment", "hash", element.getHashElement(), -1); 348 if (element.hasTitleElement()) 349 composeString(t, "Attachment", "title", element.getTitleElement(), -1); 350 if (element.hasCreationElement()) 351 composeDateTime(t, "Attachment", "creation", element.getCreationElement(), -1); 352 } 353 354 protected void composeRatio(Complex parent, String parentType, String name, Ratio element, int index) { 355 if (element == null) 356 return; 357 Complex t; 358 if (Utilities.noString(parentType)) 359 t = parent; 360 else { 361 t = parent.predicate("fhir:"+parentType+'.'+name); 362 } 363 composeElement(t, "Ratio", name, element, index); 364 if (element.hasNumerator()) 365 composeQuantity(t, "Ratio", "numerator", element.getNumerator(), -1); 366 if (element.hasDenominator()) 367 composeQuantity(t, "Ratio", "denominator", element.getDenominator(), -1); 368 } 369 370 protected void composeAnnotation(Complex parent, String parentType, String name, Annotation element, int index) { 371 if (element == null) 372 return; 373 Complex t; 374 if (Utilities.noString(parentType)) 375 t = parent; 376 else { 377 t = parent.predicate("fhir:"+parentType+'.'+name); 378 } 379 composeElement(t, "Annotation", name, element, index); 380 if (element.hasAuthor()) 381 composeType(t, "Annotation", "author", element.getAuthor(), -1); 382 if (element.hasTimeElement()) 383 composeDateTime(t, "Annotation", "time", element.getTimeElement(), -1); 384 if (element.hasTextElement()) 385 composeString(t, "Annotation", "text", element.getTextElement(), -1); 386 } 387 388 protected void composeSampledData(Complex parent, String parentType, String name, SampledData element, int index) { 389 if (element == null) 390 return; 391 Complex t; 392 if (Utilities.noString(parentType)) 393 t = parent; 394 else { 395 t = parent.predicate("fhir:"+parentType+'.'+name); 396 } 397 composeElement(t, "SampledData", name, element, index); 398 if (element.hasOrigin()) 399 composeQuantity(t, "SampledData", "origin", element.getOrigin(), -1); 400 if (element.hasPeriodElement()) 401 composeDecimal(t, "SampledData", "period", element.getPeriodElement(), -1); 402 if (element.hasFactorElement()) 403 composeDecimal(t, "SampledData", "factor", element.getFactorElement(), -1); 404 if (element.hasLowerLimitElement()) 405 composeDecimal(t, "SampledData", "lowerLimit", element.getLowerLimitElement(), -1); 406 if (element.hasUpperLimitElement()) 407 composeDecimal(t, "SampledData", "upperLimit", element.getUpperLimitElement(), -1); 408 if (element.hasDimensionsElement()) 409 composePositiveInt(t, "SampledData", "dimensions", element.getDimensionsElement(), -1); 410 if (element.hasDataElement()) 411 composeString(t, "SampledData", "data", element.getDataElement(), -1); 412 } 413 414 protected void composeReference(Complex parent, String parentType, String name, Reference element, int index) { 415 if (element == null) 416 return; 417 Complex t; 418 if (Utilities.noString(parentType)) 419 t = parent; 420 else { 421 t = parent.predicate("fhir:"+parentType+'.'+name); 422 } 423 composeElement(t, "Reference", name, element, index); 424 if (element.hasReferenceElement()) 425 composeString(t, "Reference", "reference", element.getReferenceElement_(), -1); 426 if (element.hasDisplayElement()) 427 composeString(t, "Reference", "display", element.getDisplayElement(), -1); 428 } 429 430 protected void composeCodeableConcept(Complex parent, String parentType, String name, CodeableConcept element, int index) { 431 if (element == null) 432 return; 433 Complex t; 434 if (Utilities.noString(parentType)) 435 t = parent; 436 else { 437 t = parent.predicate("fhir:"+parentType+'.'+name); 438 } 439 composeElement(t, "CodeableConcept", name, element, index); 440 decorateCodeableConcept(t, element); 441 for (int i = 0; i < element.getCoding().size(); i++) 442 composeCoding(t, "CodeableConcept", "coding", element.getCoding().get(i), i); 443 if (element.hasTextElement()) 444 composeString(t, "CodeableConcept", "text", element.getTextElement(), -1); 445 } 446 447 protected void composeIdentifier(Complex parent, String parentType, String name, Identifier element, int index) { 448 if (element == null) 449 return; 450 Complex t; 451 if (Utilities.noString(parentType)) 452 t = parent; 453 else { 454 t = parent.predicate("fhir:"+parentType+'.'+name); 455 } 456 composeElement(t, "Identifier", name, element, index); 457 if (element.hasUseElement()) 458 composeEnum(t, "Identifier", "use", element.getUseElement(), -1); 459 if (element.hasType()) 460 composeCodeableConcept(t, "Identifier", "type", element.getType(), -1); 461 if (element.hasSystemElement()) 462 composeUri(t, "Identifier", "system", element.getSystemElement(), -1); 463 if (element.hasValueElement()) 464 composeString(t, "Identifier", "value", element.getValueElement(), -1); 465 if (element.hasPeriod()) 466 composePeriod(t, "Identifier", "period", element.getPeriod(), -1); 467 if (element.hasAssigner()) 468 composeReference(t, "Identifier", "assigner", element.getAssigner(), -1); 469 } 470 471 protected void composeSignature(Complex parent, String parentType, String name, Signature element, int index) { 472 if (element == null) 473 return; 474 Complex t; 475 if (Utilities.noString(parentType)) 476 t = parent; 477 else { 478 t = parent.predicate("fhir:"+parentType+'.'+name); 479 } 480 composeElement(t, "Signature", name, element, index); 481 for (int i = 0; i < element.getType().size(); i++) 482 composeCoding(t, "Signature", "type", element.getType().get(i), i); 483 if (element.hasWhenElement()) 484 composeInstant(t, "Signature", "when", element.getWhenElement(), -1); 485 if (element.hasWho()) 486 composeType(t, "Signature", "who", element.getWho(), -1); 487 if (element.hasContentTypeElement()) 488 composeCode(t, "Signature", "contentType", element.getContentTypeElement(), -1); 489 if (element.hasBlobElement()) 490 composeBase64Binary(t, "Signature", "blob", element.getBlobElement(), -1); 491 } 492 493 protected void composeTriggerDefinition(Complex parent, String parentType, String name, TriggerDefinition element, int index) { 494 if (element == null) 495 return; 496 Complex t; 497 if (Utilities.noString(parentType)) 498 t = parent; 499 else { 500 t = parent.predicate("fhir:"+parentType+'.'+name); 501 } 502 composeElement(t, "TriggerDefinition", name, element, index); 503 if (element.hasTypeElement()) 504 composeEnum(t, "TriggerDefinition", "type", element.getTypeElement(), -1); 505 if (element.hasEventNameElement()) 506 composeString(t, "TriggerDefinition", "eventName", element.getEventNameElement(), -1); 507 if (element.hasEventTiming()) 508 composeType(t, "TriggerDefinition", "eventTiming", element.getEventTiming(), -1); 509 if (element.hasEventData()) 510 composeDataRequirement(t, "TriggerDefinition", "eventData", element.getEventData(), -1); 511 } 512 513 protected void composeElementDefinition(Complex parent, String parentType, String name, ElementDefinition element, int index) { 514 if (element == null) 515 return; 516 Complex t; 517 if (Utilities.noString(parentType)) 518 t = parent; 519 else { 520 t = parent.predicate("fhir:"+parentType+'.'+name); 521 } 522 composeElement(t, "ElementDefinition", name, element, index); 523 if (element.hasPathElement()) 524 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 525 for (int i = 0; i < element.getRepresentation().size(); i++) 526 composeEnum(t, "ElementDefinition", "representation", element.getRepresentation().get(i), i); 527 if (element.hasNameElement()) 528 composeString(t, "ElementDefinition", "name", element.getNameElement(), -1); 529 if (element.hasLabelElement()) 530 composeString(t, "ElementDefinition", "label", element.getLabelElement(), -1); 531 for (int i = 0; i < element.getCode().size(); i++) 532 composeCoding(t, "ElementDefinition", "code", element.getCode().get(i), i); 533 if (element.hasSlicing()) 534 composeElementDefinitionElementDefinitionSlicingComponent(t, "ElementDefinition", "slicing", element.getSlicing(), -1); 535 if (element.hasShortElement()) 536 composeString(t, "ElementDefinition", "short", element.getShortElement(), -1); 537 if (element.hasDefinitionElement()) 538 composeMarkdown(t, "ElementDefinition", "definition", element.getDefinitionElement(), -1); 539 if (element.hasCommentsElement()) 540 composeMarkdown(t, "ElementDefinition", "comments", element.getCommentsElement(), -1); 541 if (element.hasRequirementsElement()) 542 composeMarkdown(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1); 543 for (int i = 0; i < element.getAlias().size(); i++) 544 composeString(t, "ElementDefinition", "alias", element.getAlias().get(i), i); 545 if (element.hasMinElement()) 546 composeInteger(t, "ElementDefinition", "min", element.getMinElement(), -1); 547 if (element.hasMaxElement()) 548 composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1); 549 if (element.hasBase()) 550 composeElementDefinitionElementDefinitionBaseComponent(t, "ElementDefinition", "base", element.getBase(), -1); 551 if (element.hasContentReferenceElement()) 552 composeUri(t, "ElementDefinition", "contentReference", element.getContentReferenceElement(), -1); 553 for (int i = 0; i < element.getType().size(); i++) 554 composeElementDefinitionTypeRefComponent(t, "ElementDefinition", "type", element.getType().get(i), i); 555 if (element.hasDefaultValue()) 556 composeType(t, "ElementDefinition", "defaultValue", element.getDefaultValue(), -1); 557 if (element.hasMeaningWhenMissingElement()) 558 composeMarkdown(t, "ElementDefinition", "meaningWhenMissing", element.getMeaningWhenMissingElement(), -1); 559 if (element.hasFixed()) 560 composeType(t, "ElementDefinition", "fixed", element.getFixed(), -1); 561 if (element.hasPattern()) 562 composeType(t, "ElementDefinition", "pattern", element.getPattern(), -1); 563 if (element.hasExample()) 564 composeType(t, "ElementDefinition", "example", element.getExample(), -1); 565 if (element.hasMinValue()) 566 composeType(t, "ElementDefinition", "minValue", element.getMinValue(), -1); 567 if (element.hasMaxValue()) 568 composeType(t, "ElementDefinition", "maxValue", element.getMaxValue(), -1); 569 if (element.hasMaxLengthElement()) 570 composeInteger(t, "ElementDefinition", "maxLength", element.getMaxLengthElement(), -1); 571 for (int i = 0; i < element.getCondition().size(); i++) 572 composeId(t, "ElementDefinition", "condition", element.getCondition().get(i), i); 573 for (int i = 0; i < element.getConstraint().size(); i++) 574 composeElementDefinitionElementDefinitionConstraintComponent(t, "ElementDefinition", "constraint", element.getConstraint().get(i), i); 575 if (element.hasMustSupportElement()) 576 composeBoolean(t, "ElementDefinition", "mustSupport", element.getMustSupportElement(), -1); 577 if (element.hasIsModifierElement()) 578 composeBoolean(t, "ElementDefinition", "isModifier", element.getIsModifierElement(), -1); 579 if (element.hasIsSummaryElement()) 580 composeBoolean(t, "ElementDefinition", "isSummary", element.getIsSummaryElement(), -1); 581 if (element.hasBinding()) 582 composeElementDefinitionElementDefinitionBindingComponent(t, "ElementDefinition", "binding", element.getBinding(), -1); 583 for (int i = 0; i < element.getMapping().size(); i++) 584 composeElementDefinitionElementDefinitionMappingComponent(t, "ElementDefinition", "mapping", element.getMapping().get(i), i); 585 } 586 587 protected void composeElementDefinitionElementDefinitionSlicingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionSlicingComponent element, int index) { 588 if (element == null) 589 return; 590 Complex t; 591 if (Utilities.noString(parentType)) 592 t = parent; 593 else { 594 t = parent.predicate("fhir:"+parentType+'.'+name); 595 } 596 composeElement(t, "slicing", name, element, index); 597 for (int i = 0; i < element.getDiscriminator().size(); i++) 598 composeString(t, "ElementDefinition", "discriminator", element.getDiscriminator().get(i), i); 599 if (element.hasDescriptionElement()) 600 composeString(t, "ElementDefinition", "description", element.getDescriptionElement(), -1); 601 if (element.hasOrderedElement()) 602 composeBoolean(t, "ElementDefinition", "ordered", element.getOrderedElement(), -1); 603 if (element.hasRulesElement()) 604 composeEnum(t, "ElementDefinition", "rules", element.getRulesElement(), -1); 605 } 606 607 protected void composeElementDefinitionElementDefinitionBaseComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBaseComponent element, int index) { 608 if (element == null) 609 return; 610 Complex t; 611 if (Utilities.noString(parentType)) 612 t = parent; 613 else { 614 t = parent.predicate("fhir:"+parentType+'.'+name); 615 } 616 composeElement(t, "base", name, element, index); 617 if (element.hasPathElement()) 618 composeString(t, "ElementDefinition", "path", element.getPathElement(), -1); 619 if (element.hasMinElement()) 620 composeInteger(t, "ElementDefinition", "min", element.getMinElement(), -1); 621 if (element.hasMaxElement()) 622 composeString(t, "ElementDefinition", "max", element.getMaxElement(), -1); 623 } 624 625 protected void composeElementDefinitionTypeRefComponent(Complex parent, String parentType, String name, ElementDefinition.TypeRefComponent element, int index) { 626 if (element == null) 627 return; 628 Complex t; 629 if (Utilities.noString(parentType)) 630 t = parent; 631 else { 632 t = parent.predicate("fhir:"+parentType+'.'+name); 633 } 634 composeElement(t, "type", name, element, index); 635 if (element.hasCodeElement()) 636 composeCode(t, "ElementDefinition", "code", element.getCodeElement(), -1); 637 for (int i = 0; i < element.getProfile().size(); i++) 638 composeUri(t, "ElementDefinition", "profile", element.getProfile().get(i), i); 639 for (int i = 0; i < element.getAggregation().size(); i++) 640 composeEnum(t, "ElementDefinition", "aggregation", element.getAggregation().get(i), i); 641 if (element.hasVersioningElement()) 642 composeEnum(t, "ElementDefinition", "versioning", element.getVersioningElement(), -1); 643 } 644 645 protected void composeElementDefinitionElementDefinitionConstraintComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionConstraintComponent element, int index) { 646 if (element == null) 647 return; 648 Complex t; 649 if (Utilities.noString(parentType)) 650 t = parent; 651 else { 652 t = parent.predicate("fhir:"+parentType+'.'+name); 653 } 654 composeElement(t, "constraint", name, element, index); 655 if (element.hasKeyElement()) 656 composeId(t, "ElementDefinition", "key", element.getKeyElement(), -1); 657 if (element.hasRequirementsElement()) 658 composeString(t, "ElementDefinition", "requirements", element.getRequirementsElement(), -1); 659 if (element.hasSeverityElement()) 660 composeEnum(t, "ElementDefinition", "severity", element.getSeverityElement(), -1); 661 if (element.hasHumanElement()) 662 composeString(t, "ElementDefinition", "human", element.getHumanElement(), -1); 663 if (element.hasExpressionElement()) 664 composeString(t, "ElementDefinition", "expression", element.getExpressionElement(), -1); 665 if (element.hasXpathElement()) 666 composeString(t, "ElementDefinition", "xpath", element.getXpathElement(), -1); 667 } 668 669 protected void composeElementDefinitionElementDefinitionBindingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionBindingComponent element, int index) { 670 if (element == null) 671 return; 672 Complex t; 673 if (Utilities.noString(parentType)) 674 t = parent; 675 else { 676 t = parent.predicate("fhir:"+parentType+'.'+name); 677 } 678 composeElement(t, "binding", name, element, index); 679 if (element.hasStrengthElement()) 680 composeEnum(t, "ElementDefinition", "strength", element.getStrengthElement(), -1); 681 if (element.hasDescriptionElement()) 682 composeString(t, "ElementDefinition", "description", element.getDescriptionElement(), -1); 683 if (element.hasValueSet()) 684 composeType(t, "ElementDefinition", "valueSet", element.getValueSet(), -1); 685 } 686 687 protected void composeElementDefinitionElementDefinitionMappingComponent(Complex parent, String parentType, String name, ElementDefinition.ElementDefinitionMappingComponent element, int index) { 688 if (element == null) 689 return; 690 Complex t; 691 if (Utilities.noString(parentType)) 692 t = parent; 693 else { 694 t = parent.predicate("fhir:"+parentType+'.'+name); 695 } 696 composeElement(t, "mapping", name, element, index); 697 if (element.hasIdentityElement()) 698 composeId(t, "ElementDefinition", "identity", element.getIdentityElement(), -1); 699 if (element.hasLanguageElement()) 700 composeCode(t, "ElementDefinition", "language", element.getLanguageElement(), -1); 701 if (element.hasMapElement()) 702 composeString(t, "ElementDefinition", "map", element.getMapElement(), -1); 703 } 704 705 protected void composeTiming(Complex parent, String parentType, String name, Timing element, int index) { 706 if (element == null) 707 return; 708 Complex t; 709 if (Utilities.noString(parentType)) 710 t = parent; 711 else { 712 t = parent.predicate("fhir:"+parentType+'.'+name); 713 } 714 composeElement(t, "Timing", name, element, index); 715 for (int i = 0; i < element.getEvent().size(); i++) 716 composeDateTime(t, "Timing", "event", element.getEvent().get(i), i); 717 if (element.hasRepeat()) 718 composeTimingTimingRepeatComponent(t, "Timing", "repeat", element.getRepeat(), -1); 719 if (element.hasCode()) 720 composeCodeableConcept(t, "Timing", "code", element.getCode(), -1); 721 } 722 723 protected void composeTimingTimingRepeatComponent(Complex parent, String parentType, String name, Timing.TimingRepeatComponent element, int index) { 724 if (element == null) 725 return; 726 Complex t; 727 if (Utilities.noString(parentType)) 728 t = parent; 729 else { 730 t = parent.predicate("fhir:"+parentType+'.'+name); 731 } 732 composeElement(t, "repeat", name, element, index); 733 if (element.hasBounds()) 734 composeType(t, "Timing", "bounds", element.getBounds(), -1); 735 if (element.hasCountElement()) 736 composeInteger(t, "Timing", "count", element.getCountElement(), -1); 737 if (element.hasCountMaxElement()) 738 composeInteger(t, "Timing", "countMax", element.getCountMaxElement(), -1); 739 if (element.hasDurationElement()) 740 composeDecimal(t, "Timing", "duration", element.getDurationElement(), -1); 741 if (element.hasDurationMaxElement()) 742 composeDecimal(t, "Timing", "durationMax", element.getDurationMaxElement(), -1); 743 if (element.hasDurationUnitElement()) 744 composeEnum(t, "Timing", "durationUnit", element.getDurationUnitElement(), -1); 745 if (element.hasFrequencyElement()) 746 composeInteger(t, "Timing", "frequency", element.getFrequencyElement(), -1); 747 if (element.hasFrequencyMaxElement()) 748 composeInteger(t, "Timing", "frequencyMax", element.getFrequencyMaxElement(), -1); 749 if (element.hasPeriodElement()) 750 composeDecimal(t, "Timing", "period", element.getPeriodElement(), -1); 751 if (element.hasPeriodMaxElement()) 752 composeDecimal(t, "Timing", "periodMax", element.getPeriodMaxElement(), -1); 753 if (element.hasPeriodUnitElement()) 754 composeEnum(t, "Timing", "periodUnit", element.getPeriodUnitElement(), -1); 755 if (element.hasWhenElement()) 756 composeEnum(t, "Timing", "when", element.getWhenElement(), -1); 757 if (element.hasOffsetElement()) 758 composeUnsignedInt(t, "Timing", "offset", element.getOffsetElement(), -1); 759 } 760 761 protected void composeModuleMetadata(Complex parent, String parentType, String name, ModuleMetadata element, int index) { 762 if (element == null) 763 return; 764 Complex t; 765 if (Utilities.noString(parentType)) 766 t = parent; 767 else { 768 t = parent.predicate("fhir:"+parentType+'.'+name); 769 } 770 composeElement(t, "ModuleMetadata", name, element, index); 771 if (element.hasUrlElement()) 772 composeUri(t, "ModuleMetadata", "url", element.getUrlElement(), -1); 773 for (int i = 0; i < element.getIdentifier().size(); i++) 774 composeIdentifier(t, "ModuleMetadata", "identifier", element.getIdentifier().get(i), i); 775 if (element.hasVersionElement()) 776 composeString(t, "ModuleMetadata", "version", element.getVersionElement(), -1); 777 if (element.hasNameElement()) 778 composeString(t, "ModuleMetadata", "name", element.getNameElement(), -1); 779 if (element.hasTitleElement()) 780 composeString(t, "ModuleMetadata", "title", element.getTitleElement(), -1); 781 if (element.hasTypeElement()) 782 composeEnum(t, "ModuleMetadata", "type", element.getTypeElement(), -1); 783 if (element.hasStatusElement()) 784 composeEnum(t, "ModuleMetadata", "status", element.getStatusElement(), -1); 785 if (element.hasExperimentalElement()) 786 composeBoolean(t, "ModuleMetadata", "experimental", element.getExperimentalElement(), -1); 787 if (element.hasDescriptionElement()) 788 composeString(t, "ModuleMetadata", "description", element.getDescriptionElement(), -1); 789 if (element.hasPurposeElement()) 790 composeString(t, "ModuleMetadata", "purpose", element.getPurposeElement(), -1); 791 if (element.hasUsageElement()) 792 composeString(t, "ModuleMetadata", "usage", element.getUsageElement(), -1); 793 if (element.hasPublicationDateElement()) 794 composeDate(t, "ModuleMetadata", "publicationDate", element.getPublicationDateElement(), -1); 795 if (element.hasLastReviewDateElement()) 796 composeDate(t, "ModuleMetadata", "lastReviewDate", element.getLastReviewDateElement(), -1); 797 if (element.hasEffectivePeriod()) 798 composePeriod(t, "ModuleMetadata", "effectivePeriod", element.getEffectivePeriod(), -1); 799 for (int i = 0; i < element.getCoverage().size(); i++) 800 composeModuleMetadataModuleMetadataCoverageComponent(t, "ModuleMetadata", "coverage", element.getCoverage().get(i), i); 801 for (int i = 0; i < element.getTopic().size(); i++) 802 composeCodeableConcept(t, "ModuleMetadata", "topic", element.getTopic().get(i), i); 803 for (int i = 0; i < element.getContributor().size(); i++) 804 composeModuleMetadataModuleMetadataContributorComponent(t, "ModuleMetadata", "contributor", element.getContributor().get(i), i); 805 if (element.hasPublisherElement()) 806 composeString(t, "ModuleMetadata", "publisher", element.getPublisherElement(), -1); 807 for (int i = 0; i < element.getContact().size(); i++) 808 composeModuleMetadataModuleMetadataContactComponent(t, "ModuleMetadata", "contact", element.getContact().get(i), i); 809 if (element.hasCopyrightElement()) 810 composeString(t, "ModuleMetadata", "copyright", element.getCopyrightElement(), -1); 811 for (int i = 0; i < element.getRelatedResource().size(); i++) 812 composeModuleMetadataModuleMetadataRelatedResourceComponent(t, "ModuleMetadata", "relatedResource", element.getRelatedResource().get(i), i); 813 } 814 815 protected void composeModuleMetadataModuleMetadataCoverageComponent(Complex parent, String parentType, String name, ModuleMetadata.ModuleMetadataCoverageComponent element, int index) { 816 if (element == null) 817 return; 818 Complex t; 819 if (Utilities.noString(parentType)) 820 t = parent; 821 else { 822 t = parent.predicate("fhir:"+parentType+'.'+name); 823 } 824 composeElement(t, "coverage", name, element, index); 825 if (element.hasFocus()) 826 composeCoding(t, "ModuleMetadata", "focus", element.getFocus(), -1); 827 if (element.hasValue()) 828 composeCodeableConcept(t, "ModuleMetadata", "value", element.getValue(), -1); 829 } 830 831 protected void composeModuleMetadataModuleMetadataContributorComponent(Complex parent, String parentType, String name, ModuleMetadata.ModuleMetadataContributorComponent element, int index) { 832 if (element == null) 833 return; 834 Complex t; 835 if (Utilities.noString(parentType)) 836 t = parent; 837 else { 838 t = parent.predicate("fhir:"+parentType+'.'+name); 839 } 840 composeElement(t, "contributor", name, element, index); 841 if (element.hasTypeElement()) 842 composeEnum(t, "ModuleMetadata", "type", element.getTypeElement(), -1); 843 if (element.hasNameElement()) 844 composeString(t, "ModuleMetadata", "name", element.getNameElement(), -1); 845 for (int i = 0; i < element.getContact().size(); i++) 846 composeModuleMetadataModuleMetadataContributorContactComponent(t, "ModuleMetadata", "contact", element.getContact().get(i), i); 847 } 848 849 protected void composeModuleMetadataModuleMetadataContributorContactComponent(Complex parent, String parentType, String name, ModuleMetadata.ModuleMetadataContributorContactComponent element, int index) { 850 if (element == null) 851 return; 852 Complex t; 853 if (Utilities.noString(parentType)) 854 t = parent; 855 else { 856 t = parent.predicate("fhir:"+parentType+'.'+name); 857 } 858 composeElement(t, "contact", name, element, index); 859 if (element.hasNameElement()) 860 composeString(t, "ModuleMetadata", "name", element.getNameElement(), -1); 861 for (int i = 0; i < element.getTelecom().size(); i++) 862 composeContactPoint(t, "ModuleMetadata", "telecom", element.getTelecom().get(i), i); 863 } 864 865 protected void composeModuleMetadataModuleMetadataContactComponent(Complex parent, String parentType, String name, ModuleMetadata.ModuleMetadataContactComponent element, int index) { 866 if (element == null) 867 return; 868 Complex t; 869 if (Utilities.noString(parentType)) 870 t = parent; 871 else { 872 t = parent.predicate("fhir:"+parentType+'.'+name); 873 } 874 composeElement(t, "contact", name, element, index); 875 if (element.hasNameElement()) 876 composeString(t, "ModuleMetadata", "name", element.getNameElement(), -1); 877 for (int i = 0; i < element.getTelecom().size(); i++) 878 composeContactPoint(t, "ModuleMetadata", "telecom", element.getTelecom().get(i), i); 879 } 880 881 protected void composeModuleMetadataModuleMetadataRelatedResourceComponent(Complex parent, String parentType, String name, ModuleMetadata.ModuleMetadataRelatedResourceComponent element, int index) { 882 if (element == null) 883 return; 884 Complex t; 885 if (Utilities.noString(parentType)) 886 t = parent; 887 else { 888 t = parent.predicate("fhir:"+parentType+'.'+name); 889 } 890 composeElement(t, "relatedResource", name, element, index); 891 if (element.hasTypeElement()) 892 composeEnum(t, "ModuleMetadata", "type", element.getTypeElement(), -1); 893 if (element.hasDocument()) 894 composeAttachment(t, "ModuleMetadata", "document", element.getDocument(), -1); 895 if (element.hasResource()) 896 composeReference(t, "ModuleMetadata", "resource", element.getResource(), -1); 897 } 898 899 protected void composeActionDefinition(Complex parent, String parentType, String name, ActionDefinition element, int index) { 900 if (element == null) 901 return; 902 Complex t; 903 if (Utilities.noString(parentType)) 904 t = parent; 905 else { 906 t = parent.predicate("fhir:"+parentType+'.'+name); 907 } 908 composeElement(t, "ActionDefinition", name, element, index); 909 if (element.hasActionIdentifier()) 910 composeIdentifier(t, "ActionDefinition", "actionIdentifier", element.getActionIdentifier(), -1); 911 if (element.hasLabelElement()) 912 composeString(t, "ActionDefinition", "label", element.getLabelElement(), -1); 913 if (element.hasTitleElement()) 914 composeString(t, "ActionDefinition", "title", element.getTitleElement(), -1); 915 if (element.hasDescriptionElement()) 916 composeString(t, "ActionDefinition", "description", element.getDescriptionElement(), -1); 917 if (element.hasTextEquivalentElement()) 918 composeString(t, "ActionDefinition", "textEquivalent", element.getTextEquivalentElement(), -1); 919 for (int i = 0; i < element.getConcept().size(); i++) 920 composeCodeableConcept(t, "ActionDefinition", "concept", element.getConcept().get(i), i); 921 for (int i = 0; i < element.getSupportingEvidence().size(); i++) 922 composeAttachment(t, "ActionDefinition", "supportingEvidence", element.getSupportingEvidence().get(i), i); 923 for (int i = 0; i < element.getDocumentation().size(); i++) 924 composeAttachment(t, "ActionDefinition", "documentation", element.getDocumentation().get(i), i); 925 if (element.hasRelatedAction()) 926 composeActionDefinitionActionDefinitionRelatedActionComponent(t, "ActionDefinition", "relatedAction", element.getRelatedAction(), -1); 927 for (int i = 0; i < element.getParticipantType().size(); i++) 928 composeEnum(t, "ActionDefinition", "participantType", element.getParticipantType().get(i), i); 929 if (element.hasTypeElement()) 930 composeEnum(t, "ActionDefinition", "type", element.getTypeElement(), -1); 931 for (int i = 0; i < element.getBehavior().size(); i++) 932 composeActionDefinitionActionDefinitionBehaviorComponent(t, "ActionDefinition", "behavior", element.getBehavior().get(i), i); 933 if (element.hasResource()) 934 composeReference(t, "ActionDefinition", "resource", element.getResource(), -1); 935 for (int i = 0; i < element.getCustomization().size(); i++) 936 composeActionDefinitionActionDefinitionCustomizationComponent(t, "ActionDefinition", "customization", element.getCustomization().get(i), i); 937 for (int i = 0; i < element.getAction().size(); i++) 938 composeActionDefinition(t, "ActionDefinition", "action", element.getAction().get(i), i); 939 } 940 941 protected void composeActionDefinitionActionDefinitionRelatedActionComponent(Complex parent, String parentType, String name, ActionDefinition.ActionDefinitionRelatedActionComponent element, int index) { 942 if (element == null) 943 return; 944 Complex t; 945 if (Utilities.noString(parentType)) 946 t = parent; 947 else { 948 t = parent.predicate("fhir:"+parentType+'.'+name); 949 } 950 composeElement(t, "relatedAction", name, element, index); 951 if (element.hasActionIdentifier()) 952 composeIdentifier(t, "ActionDefinition", "actionIdentifier", element.getActionIdentifier(), -1); 953 if (element.hasRelationshipElement()) 954 composeEnum(t, "ActionDefinition", "relationship", element.getRelationshipElement(), -1); 955 if (element.hasOffset()) 956 composeType(t, "ActionDefinition", "offset", element.getOffset(), -1); 957 if (element.hasAnchorElement()) 958 composeEnum(t, "ActionDefinition", "anchor", element.getAnchorElement(), -1); 959 } 960 961 protected void composeActionDefinitionActionDefinitionBehaviorComponent(Complex parent, String parentType, String name, ActionDefinition.ActionDefinitionBehaviorComponent element, int index) { 962 if (element == null) 963 return; 964 Complex t; 965 if (Utilities.noString(parentType)) 966 t = parent; 967 else { 968 t = parent.predicate("fhir:"+parentType+'.'+name); 969 } 970 composeElement(t, "behavior", name, element, index); 971 if (element.hasType()) 972 composeCoding(t, "ActionDefinition", "type", element.getType(), -1); 973 if (element.hasValue()) 974 composeCoding(t, "ActionDefinition", "value", element.getValue(), -1); 975 } 976 977 protected void composeActionDefinitionActionDefinitionCustomizationComponent(Complex parent, String parentType, String name, ActionDefinition.ActionDefinitionCustomizationComponent element, int index) { 978 if (element == null) 979 return; 980 Complex t; 981 if (Utilities.noString(parentType)) 982 t = parent; 983 else { 984 t = parent.predicate("fhir:"+parentType+'.'+name); 985 } 986 composeElement(t, "customization", name, element, index); 987 if (element.hasPathElement()) 988 composeString(t, "ActionDefinition", "path", element.getPathElement(), -1); 989 if (element.hasExpressionElement()) 990 composeString(t, "ActionDefinition", "expression", element.getExpressionElement(), -1); 991 } 992 993 protected void composeAddress(Complex parent, String parentType, String name, Address element, int index) { 994 if (element == null) 995 return; 996 Complex t; 997 if (Utilities.noString(parentType)) 998 t = parent; 999 else { 1000 t = parent.predicate("fhir:"+parentType+'.'+name); 1001 } 1002 composeElement(t, "Address", name, element, index); 1003 if (element.hasUseElement()) 1004 composeEnum(t, "Address", "use", element.getUseElement(), -1); 1005 if (element.hasTypeElement()) 1006 composeEnum(t, "Address", "type", element.getTypeElement(), -1); 1007 if (element.hasTextElement()) 1008 composeString(t, "Address", "text", element.getTextElement(), -1); 1009 for (int i = 0; i < element.getLine().size(); i++) 1010 composeString(t, "Address", "line", element.getLine().get(i), i); 1011 if (element.hasCityElement()) 1012 composeString(t, "Address", "city", element.getCityElement(), -1); 1013 if (element.hasDistrictElement()) 1014 composeString(t, "Address", "district", element.getDistrictElement(), -1); 1015 if (element.hasStateElement()) 1016 composeString(t, "Address", "state", element.getStateElement(), -1); 1017 if (element.hasPostalCodeElement()) 1018 composeString(t, "Address", "postalCode", element.getPostalCodeElement(), -1); 1019 if (element.hasCountryElement()) 1020 composeString(t, "Address", "country", element.getCountryElement(), -1); 1021 if (element.hasPeriod()) 1022 composePeriod(t, "Address", "period", element.getPeriod(), -1); 1023 } 1024 1025 protected void composeHumanName(Complex parent, String parentType, String name, HumanName element, int index) { 1026 if (element == null) 1027 return; 1028 Complex t; 1029 if (Utilities.noString(parentType)) 1030 t = parent; 1031 else { 1032 t = parent.predicate("fhir:"+parentType+'.'+name); 1033 } 1034 composeElement(t, "HumanName", name, element, index); 1035 if (element.hasUseElement()) 1036 composeEnum(t, "HumanName", "use", element.getUseElement(), -1); 1037 if (element.hasTextElement()) 1038 composeString(t, "HumanName", "text", element.getTextElement(), -1); 1039 for (int i = 0; i < element.getFamily().size(); i++) 1040 composeString(t, "HumanName", "family", element.getFamily().get(i), i); 1041 for (int i = 0; i < element.getGiven().size(); i++) 1042 composeString(t, "HumanName", "given", element.getGiven().get(i), i); 1043 for (int i = 0; i < element.getPrefix().size(); i++) 1044 composeString(t, "HumanName", "prefix", element.getPrefix().get(i), i); 1045 for (int i = 0; i < element.getSuffix().size(); i++) 1046 composeString(t, "HumanName", "suffix", element.getSuffix().get(i), i); 1047 if (element.hasPeriod()) 1048 composePeriod(t, "HumanName", "period", element.getPeriod(), -1); 1049 } 1050 1051 protected void composeDataRequirement(Complex parent, String parentType, String name, DataRequirement element, int index) { 1052 if (element == null) 1053 return; 1054 Complex t; 1055 if (Utilities.noString(parentType)) 1056 t = parent; 1057 else { 1058 t = parent.predicate("fhir:"+parentType+'.'+name); 1059 } 1060 composeElement(t, "DataRequirement", name, element, index); 1061 if (element.hasTypeElement()) 1062 composeCode(t, "DataRequirement", "type", element.getTypeElement(), -1); 1063 if (element.hasProfile()) 1064 composeReference(t, "DataRequirement", "profile", element.getProfile(), -1); 1065 for (int i = 0; i < element.getMustSupport().size(); i++) 1066 composeString(t, "DataRequirement", "mustSupport", element.getMustSupport().get(i), i); 1067 for (int i = 0; i < element.getCodeFilter().size(); i++) 1068 composeDataRequirementDataRequirementCodeFilterComponent(t, "DataRequirement", "codeFilter", element.getCodeFilter().get(i), i); 1069 for (int i = 0; i < element.getDateFilter().size(); i++) 1070 composeDataRequirementDataRequirementDateFilterComponent(t, "DataRequirement", "dateFilter", element.getDateFilter().get(i), i); 1071 } 1072 1073 protected void composeDataRequirementDataRequirementCodeFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementCodeFilterComponent element, int index) { 1074 if (element == null) 1075 return; 1076 Complex t; 1077 if (Utilities.noString(parentType)) 1078 t = parent; 1079 else { 1080 t = parent.predicate("fhir:"+parentType+'.'+name); 1081 } 1082 composeElement(t, "codeFilter", name, element, index); 1083 if (element.hasPathElement()) 1084 composeString(t, "DataRequirement", "path", element.getPathElement(), -1); 1085 if (element.hasValueSet()) 1086 composeType(t, "DataRequirement", "valueSet", element.getValueSet(), -1); 1087 for (int i = 0; i < element.getValueCode().size(); i++) 1088 composeCode(t, "DataRequirement", "valueCode", element.getValueCode().get(i), i); 1089 for (int i = 0; i < element.getValueCoding().size(); i++) 1090 composeCoding(t, "DataRequirement", "valueCoding", element.getValueCoding().get(i), i); 1091 for (int i = 0; i < element.getValueCodeableConcept().size(); i++) 1092 composeCodeableConcept(t, "DataRequirement", "valueCodeableConcept", element.getValueCodeableConcept().get(i), i); 1093 } 1094 1095 protected void composeDataRequirementDataRequirementDateFilterComponent(Complex parent, String parentType, String name, DataRequirement.DataRequirementDateFilterComponent element, int index) { 1096 if (element == null) 1097 return; 1098 Complex t; 1099 if (Utilities.noString(parentType)) 1100 t = parent; 1101 else { 1102 t = parent.predicate("fhir:"+parentType+'.'+name); 1103 } 1104 composeElement(t, "dateFilter", name, element, index); 1105 if (element.hasPathElement()) 1106 composeString(t, "DataRequirement", "path", element.getPathElement(), -1); 1107 if (element.hasValue()) 1108 composeType(t, "DataRequirement", "value", element.getValue(), -1); 1109 } 1110 1111 protected void composeMeta(Complex parent, String parentType, String name, Meta element, int index) { 1112 if (element == null) 1113 return; 1114 Complex t; 1115 if (Utilities.noString(parentType)) 1116 t = parent; 1117 else { 1118 t = parent.predicate("fhir:"+parentType+'.'+name); 1119 } 1120 composeElement(t, "Meta", name, element, index); 1121 if (element.hasVersionIdElement()) 1122 composeId(t, "Meta", "versionId", element.getVersionIdElement(), -1); 1123 if (element.hasLastUpdatedElement()) 1124 composeInstant(t, "Meta", "lastUpdated", element.getLastUpdatedElement(), -1); 1125 for (int i = 0; i < element.getProfile().size(); i++) 1126 composeUri(t, "Meta", "profile", element.getProfile().get(i), i); 1127 for (int i = 0; i < element.getSecurity().size(); i++) 1128 composeCoding(t, "Meta", "security", element.getSecurity().get(i), i); 1129 for (int i = 0; i < element.getTag().size(); i++) 1130 composeCoding(t, "Meta", "tag", element.getTag().get(i), i); 1131 } 1132 1133 protected void composeParameterDefinition(Complex parent, String parentType, String name, ParameterDefinition element, int index) { 1134 if (element == null) 1135 return; 1136 Complex t; 1137 if (Utilities.noString(parentType)) 1138 t = parent; 1139 else { 1140 t = parent.predicate("fhir:"+parentType+'.'+name); 1141 } 1142 composeElement(t, "ParameterDefinition", name, element, index); 1143 if (element.hasNameElement()) 1144 composeCode(t, "ParameterDefinition", "name", element.getNameElement(), -1); 1145 if (element.hasUseElement()) 1146 composeCode(t, "ParameterDefinition", "use", element.getUseElement(), -1); 1147 if (element.hasMinElement()) 1148 composeInteger(t, "ParameterDefinition", "min", element.getMinElement(), -1); 1149 if (element.hasMaxElement()) 1150 composeString(t, "ParameterDefinition", "max", element.getMaxElement(), -1); 1151 if (element.hasDocumentationElement()) 1152 composeString(t, "ParameterDefinition", "documentation", element.getDocumentationElement(), -1); 1153 if (element.hasTypeElement()) 1154 composeCode(t, "ParameterDefinition", "type", element.getTypeElement(), -1); 1155 if (element.hasProfile()) 1156 composeReference(t, "ParameterDefinition", "profile", element.getProfile(), -1); 1157 } 1158 1159 protected void composeContactPoint(Complex parent, String parentType, String name, ContactPoint element, int index) { 1160 if (element == null) 1161 return; 1162 Complex t; 1163 if (Utilities.noString(parentType)) 1164 t = parent; 1165 else { 1166 t = parent.predicate("fhir:"+parentType+'.'+name); 1167 } 1168 composeElement(t, "ContactPoint", name, element, index); 1169 if (element.hasSystemElement()) 1170 composeEnum(t, "ContactPoint", "system", element.getSystemElement(), -1); 1171 if (element.hasValueElement()) 1172 composeString(t, "ContactPoint", "value", element.getValueElement(), -1); 1173 if (element.hasUseElement()) 1174 composeEnum(t, "ContactPoint", "use", element.getUseElement(), -1); 1175 if (element.hasRankElement()) 1176 composePositiveInt(t, "ContactPoint", "rank", element.getRankElement(), -1); 1177 if (element.hasPeriod()) 1178 composePeriod(t, "ContactPoint", "period", element.getPeriod(), -1); 1179 } 1180 1181 protected void composeParameters(Complex parent, String parentType, String name, Parameters element, int index) { 1182 if (element == null) 1183 return; 1184 Complex t; 1185 if (Utilities.noString(parentType)) 1186 t = parent; 1187 else { 1188 t = parent.predicate("fhir:"+parentType+'.'+name); 1189 } 1190 composeResource(t, "Parameters", name, element, index); 1191 for (int i = 0; i < element.getParameter().size(); i++) 1192 composeParametersParametersParameterComponent(t, "Parameters", "parameter", element.getParameter().get(i), i); 1193 } 1194 1195 protected void composeParametersParametersParameterComponent(Complex parent, String parentType, String name, Parameters.ParametersParameterComponent element, int index) { 1196 if (element == null) 1197 return; 1198 Complex t; 1199 if (Utilities.noString(parentType)) 1200 t = parent; 1201 else { 1202 t = parent.predicate("fhir:"+parentType+'.'+name); 1203 } 1204 composeBackboneElement(t, "parameter", name, element, index); 1205 if (element.hasNameElement()) 1206 composeString(t, "Parameters", "name", element.getNameElement(), -1); 1207 if (element.hasValue()) 1208 composeType(t, "Parameters", "value", element.getValue(), -1); 1209 if (element.hasResource()) 1210 composeResource(t, "Parameters", "resource", element.getResource(), -1); 1211 for (int i = 0; i < element.getPart().size(); i++) 1212 composeParametersParametersParameterComponent(t, "Parameters", "part", element.getPart().get(i), i); 1213 } 1214 1215 protected void composeResource(Complex t, String parentType, String name, Resource element, int index) { 1216 if (element.hasIdElement()) 1217 composeId(t, "Resource", "id", element.getIdElement(), -1); 1218 if (element.hasMeta()) 1219 composeMeta(t, "Resource", "meta", element.getMeta(), -1); 1220 if (element.hasImplicitRulesElement()) 1221 composeUri(t, "Resource", "implicitRules", element.getImplicitRulesElement(), -1); 1222 if (element.hasLanguageElement()) 1223 composeCode(t, "Resource", "language", element.getLanguageElement(), -1); 1224 } 1225 1226 protected void composeDomainResource(Complex t, String parentType, String name, DomainResource element, int index) { 1227 composeResource(t, parentType, name, element, index); 1228 if (element.hasText()) 1229 composeNarrative(t, "DomainResource", "text", element.getText(), -1); 1230 for (int i = 0; i < element.getContained().size(); i++) 1231 composeResource(t, "DomainResource", "contained", element.getContained().get(i), i); 1232 for (int i = 0; i < element.getExtension().size(); i++) 1233 composeExtension(t, "DomainResource", "extension", element.getExtension().get(i), i); 1234 for (int i = 0; i < element.getModifierExtension().size(); i++) 1235 composeExtension(t, "DomainResource", "modifierExtension", element.getModifierExtension().get(i), i); 1236 } 1237 1238 protected void composeAccount(Complex parent, String parentType, String name, Account element, int index) { 1239 if (element == null) 1240 return; 1241 Complex t; 1242 if (Utilities.noString(parentType)) 1243 t = parent; 1244 else { 1245 t = parent.predicate("fhir:"+parentType+'.'+name); 1246 } 1247 composeDomainResource(t, "Account", name, element, index); 1248 for (int i = 0; i < element.getIdentifier().size(); i++) 1249 composeIdentifier(t, "Account", "identifier", element.getIdentifier().get(i), i); 1250 if (element.hasNameElement()) 1251 composeString(t, "Account", "name", element.getNameElement(), -1); 1252 if (element.hasType()) 1253 composeCodeableConcept(t, "Account", "type", element.getType(), -1); 1254 if (element.hasStatusElement()) 1255 composeEnum(t, "Account", "status", element.getStatusElement(), -1); 1256 if (element.hasActivePeriod()) 1257 composePeriod(t, "Account", "activePeriod", element.getActivePeriod(), -1); 1258 if (element.hasCurrency()) 1259 composeCoding(t, "Account", "currency", element.getCurrency(), -1); 1260 if (element.hasBalance()) 1261 composeQuantity(t, "Account", "balance", element.getBalance(), -1); 1262 if (element.hasCoveragePeriod()) 1263 composePeriod(t, "Account", "coveragePeriod", element.getCoveragePeriod(), -1); 1264 if (element.hasSubject()) 1265 composeReference(t, "Account", "subject", element.getSubject(), -1); 1266 if (element.hasOwner()) 1267 composeReference(t, "Account", "owner", element.getOwner(), -1); 1268 if (element.hasDescriptionElement()) 1269 composeString(t, "Account", "description", element.getDescriptionElement(), -1); 1270 } 1271 1272 protected void composeAllergyIntolerance(Complex parent, String parentType, String name, AllergyIntolerance element, int index) { 1273 if (element == null) 1274 return; 1275 Complex t; 1276 if (Utilities.noString(parentType)) 1277 t = parent; 1278 else { 1279 t = parent.predicate("fhir:"+parentType+'.'+name); 1280 } 1281 composeDomainResource(t, "AllergyIntolerance", name, element, index); 1282 for (int i = 0; i < element.getIdentifier().size(); i++) 1283 composeIdentifier(t, "AllergyIntolerance", "identifier", element.getIdentifier().get(i), i); 1284 if (element.hasStatusElement()) 1285 composeEnum(t, "AllergyIntolerance", "status", element.getStatusElement(), -1); 1286 if (element.hasTypeElement()) 1287 composeEnum(t, "AllergyIntolerance", "type", element.getTypeElement(), -1); 1288 if (element.hasCategoryElement()) 1289 composeEnum(t, "AllergyIntolerance", "category", element.getCategoryElement(), -1); 1290 if (element.hasCriticalityElement()) 1291 composeEnum(t, "AllergyIntolerance", "criticality", element.getCriticalityElement(), -1); 1292 if (element.hasSubstance()) 1293 composeCodeableConcept(t, "AllergyIntolerance", "substance", element.getSubstance(), -1); 1294 if (element.hasPatient()) 1295 composeReference(t, "AllergyIntolerance", "patient", element.getPatient(), -1); 1296 if (element.hasRecordedDateElement()) 1297 composeDateTime(t, "AllergyIntolerance", "recordedDate", element.getRecordedDateElement(), -1); 1298 if (element.hasRecorder()) 1299 composeReference(t, "AllergyIntolerance", "recorder", element.getRecorder(), -1); 1300 if (element.hasReporter()) 1301 composeReference(t, "AllergyIntolerance", "reporter", element.getReporter(), -1); 1302 if (element.hasOnsetElement()) 1303 composeDateTime(t, "AllergyIntolerance", "onset", element.getOnsetElement(), -1); 1304 if (element.hasLastOccurenceElement()) 1305 composeDateTime(t, "AllergyIntolerance", "lastOccurence", element.getLastOccurenceElement(), -1); 1306 for (int i = 0; i < element.getNote().size(); i++) 1307 composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i); 1308 for (int i = 0; i < element.getReaction().size(); i++) 1309 composeAllergyIntoleranceAllergyIntoleranceReactionComponent(t, "AllergyIntolerance", "reaction", element.getReaction().get(i), i); 1310 } 1311 1312 protected void composeAllergyIntoleranceAllergyIntoleranceReactionComponent(Complex parent, String parentType, String name, AllergyIntolerance.AllergyIntoleranceReactionComponent element, int index) { 1313 if (element == null) 1314 return; 1315 Complex t; 1316 if (Utilities.noString(parentType)) 1317 t = parent; 1318 else { 1319 t = parent.predicate("fhir:"+parentType+'.'+name); 1320 } 1321 composeBackboneElement(t, "reaction", name, element, index); 1322 if (element.hasSubstance()) 1323 composeCodeableConcept(t, "AllergyIntolerance", "substance", element.getSubstance(), -1); 1324 if (element.hasCertaintyElement()) 1325 composeEnum(t, "AllergyIntolerance", "certainty", element.getCertaintyElement(), -1); 1326 for (int i = 0; i < element.getManifestation().size(); i++) 1327 composeCodeableConcept(t, "AllergyIntolerance", "manifestation", element.getManifestation().get(i), i); 1328 if (element.hasDescriptionElement()) 1329 composeString(t, "AllergyIntolerance", "description", element.getDescriptionElement(), -1); 1330 if (element.hasOnsetElement()) 1331 composeDateTime(t, "AllergyIntolerance", "onset", element.getOnsetElement(), -1); 1332 if (element.hasSeverityElement()) 1333 composeEnum(t, "AllergyIntolerance", "severity", element.getSeverityElement(), -1); 1334 if (element.hasExposureRoute()) 1335 composeCodeableConcept(t, "AllergyIntolerance", "exposureRoute", element.getExposureRoute(), -1); 1336 for (int i = 0; i < element.getNote().size(); i++) 1337 composeAnnotation(t, "AllergyIntolerance", "note", element.getNote().get(i), i); 1338 } 1339 1340 protected void composeAppointment(Complex parent, String parentType, String name, Appointment element, int index) { 1341 if (element == null) 1342 return; 1343 Complex t; 1344 if (Utilities.noString(parentType)) 1345 t = parent; 1346 else { 1347 t = parent.predicate("fhir:"+parentType+'.'+name); 1348 } 1349 composeDomainResource(t, "Appointment", name, element, index); 1350 for (int i = 0; i < element.getIdentifier().size(); i++) 1351 composeIdentifier(t, "Appointment", "identifier", element.getIdentifier().get(i), i); 1352 if (element.hasStatusElement()) 1353 composeEnum(t, "Appointment", "status", element.getStatusElement(), -1); 1354 if (element.hasServiceCategory()) 1355 composeCodeableConcept(t, "Appointment", "serviceCategory", element.getServiceCategory(), -1); 1356 for (int i = 0; i < element.getServiceType().size(); i++) 1357 composeCodeableConcept(t, "Appointment", "serviceType", element.getServiceType().get(i), i); 1358 for (int i = 0; i < element.getSpecialty().size(); i++) 1359 composeCodeableConcept(t, "Appointment", "specialty", element.getSpecialty().get(i), i); 1360 if (element.hasAppointmentType()) 1361 composeCodeableConcept(t, "Appointment", "appointmentType", element.getAppointmentType(), -1); 1362 if (element.hasReason()) 1363 composeCodeableConcept(t, "Appointment", "reason", element.getReason(), -1); 1364 if (element.hasPriorityElement()) 1365 composeUnsignedInt(t, "Appointment", "priority", element.getPriorityElement(), -1); 1366 if (element.hasDescriptionElement()) 1367 composeString(t, "Appointment", "description", element.getDescriptionElement(), -1); 1368 if (element.hasStartElement()) 1369 composeInstant(t, "Appointment", "start", element.getStartElement(), -1); 1370 if (element.hasEndElement()) 1371 composeInstant(t, "Appointment", "end", element.getEndElement(), -1); 1372 if (element.hasMinutesDurationElement()) 1373 composePositiveInt(t, "Appointment", "minutesDuration", element.getMinutesDurationElement(), -1); 1374 for (int i = 0; i < element.getSlot().size(); i++) 1375 composeReference(t, "Appointment", "slot", element.getSlot().get(i), i); 1376 if (element.hasCreatedElement()) 1377 composeDateTime(t, "Appointment", "created", element.getCreatedElement(), -1); 1378 if (element.hasCommentElement()) 1379 composeString(t, "Appointment", "comment", element.getCommentElement(), -1); 1380 for (int i = 0; i < element.getParticipant().size(); i++) 1381 composeAppointmentAppointmentParticipantComponent(t, "Appointment", "participant", element.getParticipant().get(i), i); 1382 } 1383 1384 protected void composeAppointmentAppointmentParticipantComponent(Complex parent, String parentType, String name, Appointment.AppointmentParticipantComponent element, int index) { 1385 if (element == null) 1386 return; 1387 Complex t; 1388 if (Utilities.noString(parentType)) 1389 t = parent; 1390 else { 1391 t = parent.predicate("fhir:"+parentType+'.'+name); 1392 } 1393 composeBackboneElement(t, "participant", name, element, index); 1394 for (int i = 0; i < element.getType().size(); i++) 1395 composeCodeableConcept(t, "Appointment", "type", element.getType().get(i), i); 1396 if (element.hasActor()) 1397 composeReference(t, "Appointment", "actor", element.getActor(), -1); 1398 if (element.hasRequiredElement()) 1399 composeEnum(t, "Appointment", "required", element.getRequiredElement(), -1); 1400 if (element.hasStatusElement()) 1401 composeEnum(t, "Appointment", "status", element.getStatusElement(), -1); 1402 } 1403 1404 protected void composeAppointmentResponse(Complex parent, String parentType, String name, AppointmentResponse element, int index) { 1405 if (element == null) 1406 return; 1407 Complex t; 1408 if (Utilities.noString(parentType)) 1409 t = parent; 1410 else { 1411 t = parent.predicate("fhir:"+parentType+'.'+name); 1412 } 1413 composeDomainResource(t, "AppointmentResponse", name, element, index); 1414 for (int i = 0; i < element.getIdentifier().size(); i++) 1415 composeIdentifier(t, "AppointmentResponse", "identifier", element.getIdentifier().get(i), i); 1416 if (element.hasAppointment()) 1417 composeReference(t, "AppointmentResponse", "appointment", element.getAppointment(), -1); 1418 if (element.hasStartElement()) 1419 composeInstant(t, "AppointmentResponse", "start", element.getStartElement(), -1); 1420 if (element.hasEndElement()) 1421 composeInstant(t, "AppointmentResponse", "end", element.getEndElement(), -1); 1422 for (int i = 0; i < element.getParticipantType().size(); i++) 1423 composeCodeableConcept(t, "AppointmentResponse", "participantType", element.getParticipantType().get(i), i); 1424 if (element.hasActor()) 1425 composeReference(t, "AppointmentResponse", "actor", element.getActor(), -1); 1426 if (element.hasParticipantStatusElement()) 1427 composeCode(t, "AppointmentResponse", "participantStatus", element.getParticipantStatusElement(), -1); 1428 if (element.hasCommentElement()) 1429 composeString(t, "AppointmentResponse", "comment", element.getCommentElement(), -1); 1430 } 1431 1432 protected void composeAuditEvent(Complex parent, String parentType, String name, AuditEvent element, int index) { 1433 if (element == null) 1434 return; 1435 Complex t; 1436 if (Utilities.noString(parentType)) 1437 t = parent; 1438 else { 1439 t = parent.predicate("fhir:"+parentType+'.'+name); 1440 } 1441 composeDomainResource(t, "AuditEvent", name, element, index); 1442 if (element.hasType()) 1443 composeCoding(t, "AuditEvent", "type", element.getType(), -1); 1444 for (int i = 0; i < element.getSubtype().size(); i++) 1445 composeCoding(t, "AuditEvent", "subtype", element.getSubtype().get(i), i); 1446 if (element.hasActionElement()) 1447 composeEnum(t, "AuditEvent", "action", element.getActionElement(), -1); 1448 if (element.hasRecordedElement()) 1449 composeInstant(t, "AuditEvent", "recorded", element.getRecordedElement(), -1); 1450 if (element.hasOutcomeElement()) 1451 composeEnum(t, "AuditEvent", "outcome", element.getOutcomeElement(), -1); 1452 if (element.hasOutcomeDescElement()) 1453 composeString(t, "AuditEvent", "outcomeDesc", element.getOutcomeDescElement(), -1); 1454 for (int i = 0; i < element.getPurposeOfEvent().size(); i++) 1455 composeCoding(t, "AuditEvent", "purposeOfEvent", element.getPurposeOfEvent().get(i), i); 1456 for (int i = 0; i < element.getAgent().size(); i++) 1457 composeAuditEventAuditEventAgentComponent(t, "AuditEvent", "agent", element.getAgent().get(i), i); 1458 if (element.hasSource()) 1459 composeAuditEventAuditEventSourceComponent(t, "AuditEvent", "source", element.getSource(), -1); 1460 for (int i = 0; i < element.getEntity().size(); i++) 1461 composeAuditEventAuditEventEntityComponent(t, "AuditEvent", "entity", element.getEntity().get(i), i); 1462 } 1463 1464 protected void composeAuditEventAuditEventAgentComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentComponent element, int index) { 1465 if (element == null) 1466 return; 1467 Complex t; 1468 if (Utilities.noString(parentType)) 1469 t = parent; 1470 else { 1471 t = parent.predicate("fhir:"+parentType+'.'+name); 1472 } 1473 composeBackboneElement(t, "agent", name, element, index); 1474 for (int i = 0; i < element.getRole().size(); i++) 1475 composeCodeableConcept(t, "AuditEvent", "role", element.getRole().get(i), i); 1476 if (element.hasReference()) 1477 composeReference(t, "AuditEvent", "reference", element.getReference(), -1); 1478 if (element.hasUserId()) 1479 composeIdentifier(t, "AuditEvent", "userId", element.getUserId(), -1); 1480 if (element.hasAltIdElement()) 1481 composeString(t, "AuditEvent", "altId", element.getAltIdElement(), -1); 1482 if (element.hasNameElement()) 1483 composeString(t, "AuditEvent", "name", element.getNameElement(), -1); 1484 if (element.hasRequestorElement()) 1485 composeBoolean(t, "AuditEvent", "requestor", element.getRequestorElement(), -1); 1486 if (element.hasLocation()) 1487 composeReference(t, "AuditEvent", "location", element.getLocation(), -1); 1488 for (int i = 0; i < element.getPolicy().size(); i++) 1489 composeUri(t, "AuditEvent", "policy", element.getPolicy().get(i), i); 1490 if (element.hasMedia()) 1491 composeCoding(t, "AuditEvent", "media", element.getMedia(), -1); 1492 if (element.hasNetwork()) 1493 composeAuditEventAuditEventAgentNetworkComponent(t, "AuditEvent", "network", element.getNetwork(), -1); 1494 for (int i = 0; i < element.getPurposeOfUse().size(); i++) 1495 composeCoding(t, "AuditEvent", "purposeOfUse", element.getPurposeOfUse().get(i), i); 1496 } 1497 1498 protected void composeAuditEventAuditEventAgentNetworkComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventAgentNetworkComponent element, int index) { 1499 if (element == null) 1500 return; 1501 Complex t; 1502 if (Utilities.noString(parentType)) 1503 t = parent; 1504 else { 1505 t = parent.predicate("fhir:"+parentType+'.'+name); 1506 } 1507 composeBackboneElement(t, "network", name, element, index); 1508 if (element.hasAddressElement()) 1509 composeString(t, "AuditEvent", "address", element.getAddressElement(), -1); 1510 if (element.hasTypeElement()) 1511 composeEnum(t, "AuditEvent", "type", element.getTypeElement(), -1); 1512 } 1513 1514 protected void composeAuditEventAuditEventSourceComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventSourceComponent element, int index) { 1515 if (element == null) 1516 return; 1517 Complex t; 1518 if (Utilities.noString(parentType)) 1519 t = parent; 1520 else { 1521 t = parent.predicate("fhir:"+parentType+'.'+name); 1522 } 1523 composeBackboneElement(t, "source", name, element, index); 1524 if (element.hasSiteElement()) 1525 composeString(t, "AuditEvent", "site", element.getSiteElement(), -1); 1526 if (element.hasIdentifier()) 1527 composeIdentifier(t, "AuditEvent", "identifier", element.getIdentifier(), -1); 1528 for (int i = 0; i < element.getType().size(); i++) 1529 composeCoding(t, "AuditEvent", "type", element.getType().get(i), i); 1530 } 1531 1532 protected void composeAuditEventAuditEventEntityComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityComponent element, int index) { 1533 if (element == null) 1534 return; 1535 Complex t; 1536 if (Utilities.noString(parentType)) 1537 t = parent; 1538 else { 1539 t = parent.predicate("fhir:"+parentType+'.'+name); 1540 } 1541 composeBackboneElement(t, "entity", name, element, index); 1542 if (element.hasIdentifier()) 1543 composeIdentifier(t, "AuditEvent", "identifier", element.getIdentifier(), -1); 1544 if (element.hasReference()) 1545 composeReference(t, "AuditEvent", "reference", element.getReference(), -1); 1546 if (element.hasType()) 1547 composeCoding(t, "AuditEvent", "type", element.getType(), -1); 1548 if (element.hasRole()) 1549 composeCoding(t, "AuditEvent", "role", element.getRole(), -1); 1550 if (element.hasLifecycle()) 1551 composeCoding(t, "AuditEvent", "lifecycle", element.getLifecycle(), -1); 1552 for (int i = 0; i < element.getSecurityLabel().size(); i++) 1553 composeCoding(t, "AuditEvent", "securityLabel", element.getSecurityLabel().get(i), i); 1554 if (element.hasNameElement()) 1555 composeString(t, "AuditEvent", "name", element.getNameElement(), -1); 1556 if (element.hasDescriptionElement()) 1557 composeString(t, "AuditEvent", "description", element.getDescriptionElement(), -1); 1558 if (element.hasQueryElement()) 1559 composeBase64Binary(t, "AuditEvent", "query", element.getQueryElement(), -1); 1560 for (int i = 0; i < element.getDetail().size(); i++) 1561 composeAuditEventAuditEventEntityDetailComponent(t, "AuditEvent", "detail", element.getDetail().get(i), i); 1562 } 1563 1564 protected void composeAuditEventAuditEventEntityDetailComponent(Complex parent, String parentType, String name, AuditEvent.AuditEventEntityDetailComponent element, int index) { 1565 if (element == null) 1566 return; 1567 Complex t; 1568 if (Utilities.noString(parentType)) 1569 t = parent; 1570 else { 1571 t = parent.predicate("fhir:"+parentType+'.'+name); 1572 } 1573 composeBackboneElement(t, "detail", name, element, index); 1574 if (element.hasTypeElement()) 1575 composeString(t, "AuditEvent", "type", element.getTypeElement(), -1); 1576 if (element.hasValueElement()) 1577 composeBase64Binary(t, "AuditEvent", "value", element.getValueElement(), -1); 1578 } 1579 1580 protected void composeBasic(Complex parent, String parentType, String name, Basic element, int index) { 1581 if (element == null) 1582 return; 1583 Complex t; 1584 if (Utilities.noString(parentType)) 1585 t = parent; 1586 else { 1587 t = parent.predicate("fhir:"+parentType+'.'+name); 1588 } 1589 composeDomainResource(t, "Basic", name, element, index); 1590 for (int i = 0; i < element.getIdentifier().size(); i++) 1591 composeIdentifier(t, "Basic", "identifier", element.getIdentifier().get(i), i); 1592 if (element.hasCode()) 1593 composeCodeableConcept(t, "Basic", "code", element.getCode(), -1); 1594 if (element.hasSubject()) 1595 composeReference(t, "Basic", "subject", element.getSubject(), -1); 1596 if (element.hasCreatedElement()) 1597 composeDate(t, "Basic", "created", element.getCreatedElement(), -1); 1598 if (element.hasAuthor()) 1599 composeReference(t, "Basic", "author", element.getAuthor(), -1); 1600 } 1601 1602 protected void composeBinary(Complex parent, String parentType, String name, Binary element, int index) { 1603 if (element == null) 1604 return; 1605 Complex t; 1606 if (Utilities.noString(parentType)) 1607 t = parent; 1608 else { 1609 t = parent.predicate("fhir:"+parentType+'.'+name); 1610 } 1611 composeResource(t, "Binary", name, element, index); 1612 if (element.hasContentTypeElement()) 1613 composeCode(t, "Binary", "contentType", element.getContentTypeElement(), -1); 1614 if (element.hasContentElement()) 1615 composeBase64Binary(t, "Binary", "content", element.getContentElement(), -1); 1616 } 1617 1618 protected void composeBodySite(Complex parent, String parentType, String name, BodySite element, int index) { 1619 if (element == null) 1620 return; 1621 Complex t; 1622 if (Utilities.noString(parentType)) 1623 t = parent; 1624 else { 1625 t = parent.predicate("fhir:"+parentType+'.'+name); 1626 } 1627 composeDomainResource(t, "BodySite", name, element, index); 1628 if (element.hasPatient()) 1629 composeReference(t, "BodySite", "patient", element.getPatient(), -1); 1630 for (int i = 0; i < element.getIdentifier().size(); i++) 1631 composeIdentifier(t, "BodySite", "identifier", element.getIdentifier().get(i), i); 1632 if (element.hasCode()) 1633 composeCodeableConcept(t, "BodySite", "code", element.getCode(), -1); 1634 for (int i = 0; i < element.getModifier().size(); i++) 1635 composeCodeableConcept(t, "BodySite", "modifier", element.getModifier().get(i), i); 1636 if (element.hasDescriptionElement()) 1637 composeString(t, "BodySite", "description", element.getDescriptionElement(), -1); 1638 for (int i = 0; i < element.getImage().size(); i++) 1639 composeAttachment(t, "BodySite", "image", element.getImage().get(i), i); 1640 } 1641 1642 protected void composeBundle(Complex parent, String parentType, String name, Bundle element, int index) { 1643 if (element == null) 1644 return; 1645 Complex t; 1646 if (Utilities.noString(parentType)) 1647 t = parent; 1648 else { 1649 t = parent.predicate("fhir:"+parentType+'.'+name); 1650 } 1651 composeResource(t, "Bundle", name, element, index); 1652 if (element.hasTypeElement()) 1653 composeEnum(t, "Bundle", "type", element.getTypeElement(), -1); 1654 if (element.hasTotalElement()) 1655 composeUnsignedInt(t, "Bundle", "total", element.getTotalElement(), -1); 1656 for (int i = 0; i < element.getLink().size(); i++) 1657 composeBundleBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i); 1658 for (int i = 0; i < element.getEntry().size(); i++) 1659 composeBundleBundleEntryComponent(t, "Bundle", "entry", element.getEntry().get(i), i); 1660 if (element.hasSignature()) 1661 composeSignature(t, "Bundle", "signature", element.getSignature(), -1); 1662 } 1663 1664 protected void composeBundleBundleLinkComponent(Complex parent, String parentType, String name, Bundle.BundleLinkComponent element, int index) { 1665 if (element == null) 1666 return; 1667 Complex t; 1668 if (Utilities.noString(parentType)) 1669 t = parent; 1670 else { 1671 t = parent.predicate("fhir:"+parentType+'.'+name); 1672 } 1673 composeBackboneElement(t, "link", name, element, index); 1674 if (element.hasRelationElement()) 1675 composeString(t, "Bundle", "relation", element.getRelationElement(), -1); 1676 if (element.hasUrlElement()) 1677 composeUri(t, "Bundle", "url", element.getUrlElement(), -1); 1678 } 1679 1680 protected void composeBundleBundleEntryComponent(Complex parent, String parentType, String name, Bundle.BundleEntryComponent element, int index) { 1681 if (element == null) 1682 return; 1683 Complex t; 1684 if (Utilities.noString(parentType)) 1685 t = parent; 1686 else { 1687 t = parent.predicate("fhir:"+parentType+'.'+name); 1688 } 1689 composeBackboneElement(t, "entry", name, element, index); 1690 for (int i = 0; i < element.getLink().size(); i++) 1691 composeBundleBundleLinkComponent(t, "Bundle", "link", element.getLink().get(i), i); 1692 if (element.hasFullUrlElement()) 1693 composeUri(t, "Bundle", "fullUrl", element.getFullUrlElement(), -1); 1694 if (element.hasResource()) 1695 composeResource(t, "Bundle", "resource", element.getResource(), -1); 1696 if (element.hasSearch()) 1697 composeBundleBundleEntrySearchComponent(t, "Bundle", "search", element.getSearch(), -1); 1698 if (element.hasRequest()) 1699 composeBundleBundleEntryRequestComponent(t, "Bundle", "request", element.getRequest(), -1); 1700 if (element.hasResponse()) 1701 composeBundleBundleEntryResponseComponent(t, "Bundle", "response", element.getResponse(), -1); 1702 } 1703 1704 protected void composeBundleBundleEntrySearchComponent(Complex parent, String parentType, String name, Bundle.BundleEntrySearchComponent element, int index) { 1705 if (element == null) 1706 return; 1707 Complex t; 1708 if (Utilities.noString(parentType)) 1709 t = parent; 1710 else { 1711 t = parent.predicate("fhir:"+parentType+'.'+name); 1712 } 1713 composeBackboneElement(t, "search", name, element, index); 1714 if (element.hasModeElement()) 1715 composeEnum(t, "Bundle", "mode", element.getModeElement(), -1); 1716 if (element.hasScoreElement()) 1717 composeDecimal(t, "Bundle", "score", element.getScoreElement(), -1); 1718 } 1719 1720 protected void composeBundleBundleEntryRequestComponent(Complex parent, String parentType, String name, Bundle.BundleEntryRequestComponent element, int index) { 1721 if (element == null) 1722 return; 1723 Complex t; 1724 if (Utilities.noString(parentType)) 1725 t = parent; 1726 else { 1727 t = parent.predicate("fhir:"+parentType+'.'+name); 1728 } 1729 composeBackboneElement(t, "request", name, element, index); 1730 if (element.hasMethodElement()) 1731 composeEnum(t, "Bundle", "method", element.getMethodElement(), -1); 1732 if (element.hasUrlElement()) 1733 composeUri(t, "Bundle", "url", element.getUrlElement(), -1); 1734 if (element.hasIfNoneMatchElement()) 1735 composeString(t, "Bundle", "ifNoneMatch", element.getIfNoneMatchElement(), -1); 1736 if (element.hasIfModifiedSinceElement()) 1737 composeInstant(t, "Bundle", "ifModifiedSince", element.getIfModifiedSinceElement(), -1); 1738 if (element.hasIfMatchElement()) 1739 composeString(t, "Bundle", "ifMatch", element.getIfMatchElement(), -1); 1740 if (element.hasIfNoneExistElement()) 1741 composeString(t, "Bundle", "ifNoneExist", element.getIfNoneExistElement(), -1); 1742 } 1743 1744 protected void composeBundleBundleEntryResponseComponent(Complex parent, String parentType, String name, Bundle.BundleEntryResponseComponent element, int index) { 1745 if (element == null) 1746 return; 1747 Complex t; 1748 if (Utilities.noString(parentType)) 1749 t = parent; 1750 else { 1751 t = parent.predicate("fhir:"+parentType+'.'+name); 1752 } 1753 composeBackboneElement(t, "response", name, element, index); 1754 if (element.hasStatusElement()) 1755 composeString(t, "Bundle", "status", element.getStatusElement(), -1); 1756 if (element.hasLocationElement()) 1757 composeUri(t, "Bundle", "location", element.getLocationElement(), -1); 1758 if (element.hasEtagElement()) 1759 composeString(t, "Bundle", "etag", element.getEtagElement(), -1); 1760 if (element.hasLastModifiedElement()) 1761 composeInstant(t, "Bundle", "lastModified", element.getLastModifiedElement(), -1); 1762 } 1763 1764 protected void composeCarePlan(Complex parent, String parentType, String name, CarePlan element, int index) { 1765 if (element == null) 1766 return; 1767 Complex t; 1768 if (Utilities.noString(parentType)) 1769 t = parent; 1770 else { 1771 t = parent.predicate("fhir:"+parentType+'.'+name); 1772 } 1773 composeDomainResource(t, "CarePlan", name, element, index); 1774 for (int i = 0; i < element.getIdentifier().size(); i++) 1775 composeIdentifier(t, "CarePlan", "identifier", element.getIdentifier().get(i), i); 1776 if (element.hasSubject()) 1777 composeReference(t, "CarePlan", "subject", element.getSubject(), -1); 1778 if (element.hasStatusElement()) 1779 composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1); 1780 if (element.hasContext()) 1781 composeReference(t, "CarePlan", "context", element.getContext(), -1); 1782 if (element.hasPeriod()) 1783 composePeriod(t, "CarePlan", "period", element.getPeriod(), -1); 1784 for (int i = 0; i < element.getAuthor().size(); i++) 1785 composeReference(t, "CarePlan", "author", element.getAuthor().get(i), i); 1786 if (element.hasModifiedElement()) 1787 composeDateTime(t, "CarePlan", "modified", element.getModifiedElement(), -1); 1788 for (int i = 0; i < element.getCategory().size(); i++) 1789 composeCodeableConcept(t, "CarePlan", "category", element.getCategory().get(i), i); 1790 if (element.hasDescriptionElement()) 1791 composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1); 1792 for (int i = 0; i < element.getAddresses().size(); i++) 1793 composeReference(t, "CarePlan", "addresses", element.getAddresses().get(i), i); 1794 for (int i = 0; i < element.getSupport().size(); i++) 1795 composeReference(t, "CarePlan", "support", element.getSupport().get(i), i); 1796 for (int i = 0; i < element.getRelatedPlan().size(); i++) 1797 composeCarePlanCarePlanRelatedPlanComponent(t, "CarePlan", "relatedPlan", element.getRelatedPlan().get(i), i); 1798 for (int i = 0; i < element.getParticipant().size(); i++) 1799 composeCarePlanCarePlanParticipantComponent(t, "CarePlan", "participant", element.getParticipant().get(i), i); 1800 for (int i = 0; i < element.getGoal().size(); i++) 1801 composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i); 1802 for (int i = 0; i < element.getActivity().size(); i++) 1803 composeCarePlanCarePlanActivityComponent(t, "CarePlan", "activity", element.getActivity().get(i), i); 1804 if (element.hasNote()) 1805 composeAnnotation(t, "CarePlan", "note", element.getNote(), -1); 1806 } 1807 1808 protected void composeCarePlanCarePlanRelatedPlanComponent(Complex parent, String parentType, String name, CarePlan.CarePlanRelatedPlanComponent element, int index) { 1809 if (element == null) 1810 return; 1811 Complex t; 1812 if (Utilities.noString(parentType)) 1813 t = parent; 1814 else { 1815 t = parent.predicate("fhir:"+parentType+'.'+name); 1816 } 1817 composeBackboneElement(t, "relatedPlan", name, element, index); 1818 if (element.hasCodeElement()) 1819 composeEnum(t, "CarePlan", "code", element.getCodeElement(), -1); 1820 if (element.hasPlan()) 1821 composeReference(t, "CarePlan", "plan", element.getPlan(), -1); 1822 } 1823 1824 protected void composeCarePlanCarePlanParticipantComponent(Complex parent, String parentType, String name, CarePlan.CarePlanParticipantComponent element, int index) { 1825 if (element == null) 1826 return; 1827 Complex t; 1828 if (Utilities.noString(parentType)) 1829 t = parent; 1830 else { 1831 t = parent.predicate("fhir:"+parentType+'.'+name); 1832 } 1833 composeBackboneElement(t, "participant", name, element, index); 1834 if (element.hasRole()) 1835 composeCodeableConcept(t, "CarePlan", "role", element.getRole(), -1); 1836 if (element.hasMember()) 1837 composeReference(t, "CarePlan", "member", element.getMember(), -1); 1838 } 1839 1840 protected void composeCarePlanCarePlanActivityComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityComponent element, int index) { 1841 if (element == null) 1842 return; 1843 Complex t; 1844 if (Utilities.noString(parentType)) 1845 t = parent; 1846 else { 1847 t = parent.predicate("fhir:"+parentType+'.'+name); 1848 } 1849 composeBackboneElement(t, "activity", name, element, index); 1850 for (int i = 0; i < element.getActionResulting().size(); i++) 1851 composeReference(t, "CarePlan", "actionResulting", element.getActionResulting().get(i), i); 1852 for (int i = 0; i < element.getProgress().size(); i++) 1853 composeAnnotation(t, "CarePlan", "progress", element.getProgress().get(i), i); 1854 if (element.hasReference()) 1855 composeReference(t, "CarePlan", "reference", element.getReference(), -1); 1856 if (element.hasDetail()) 1857 composeCarePlanCarePlanActivityDetailComponent(t, "CarePlan", "detail", element.getDetail(), -1); 1858 } 1859 1860 protected void composeCarePlanCarePlanActivityDetailComponent(Complex parent, String parentType, String name, CarePlan.CarePlanActivityDetailComponent element, int index) { 1861 if (element == null) 1862 return; 1863 Complex t; 1864 if (Utilities.noString(parentType)) 1865 t = parent; 1866 else { 1867 t = parent.predicate("fhir:"+parentType+'.'+name); 1868 } 1869 composeBackboneElement(t, "detail", name, element, index); 1870 if (element.hasCategory()) 1871 composeCodeableConcept(t, "CarePlan", "category", element.getCategory(), -1); 1872 if (element.hasCode()) 1873 composeCodeableConcept(t, "CarePlan", "code", element.getCode(), -1); 1874 for (int i = 0; i < element.getReasonCode().size(); i++) 1875 composeCodeableConcept(t, "CarePlan", "reasonCode", element.getReasonCode().get(i), i); 1876 for (int i = 0; i < element.getReasonReference().size(); i++) 1877 composeReference(t, "CarePlan", "reasonReference", element.getReasonReference().get(i), i); 1878 for (int i = 0; i < element.getGoal().size(); i++) 1879 composeReference(t, "CarePlan", "goal", element.getGoal().get(i), i); 1880 if (element.hasStatusElement()) 1881 composeEnum(t, "CarePlan", "status", element.getStatusElement(), -1); 1882 if (element.hasStatusReason()) 1883 composeCodeableConcept(t, "CarePlan", "statusReason", element.getStatusReason(), -1); 1884 if (element.hasProhibitedElement()) 1885 composeBoolean(t, "CarePlan", "prohibited", element.getProhibitedElement(), -1); 1886 if (element.hasScheduled()) 1887 composeType(t, "CarePlan", "scheduled", element.getScheduled(), -1); 1888 if (element.hasLocation()) 1889 composeReference(t, "CarePlan", "location", element.getLocation(), -1); 1890 for (int i = 0; i < element.getPerformer().size(); i++) 1891 composeReference(t, "CarePlan", "performer", element.getPerformer().get(i), i); 1892 if (element.hasProduct()) 1893 composeType(t, "CarePlan", "product", element.getProduct(), -1); 1894 if (element.hasDailyAmount()) 1895 composeQuantity(t, "CarePlan", "dailyAmount", element.getDailyAmount(), -1); 1896 if (element.hasQuantity()) 1897 composeQuantity(t, "CarePlan", "quantity", element.getQuantity(), -1); 1898 if (element.hasDescriptionElement()) 1899 composeString(t, "CarePlan", "description", element.getDescriptionElement(), -1); 1900 } 1901 1902 protected void composeCareTeam(Complex parent, String parentType, String name, CareTeam element, int index) { 1903 if (element == null) 1904 return; 1905 Complex t; 1906 if (Utilities.noString(parentType)) 1907 t = parent; 1908 else { 1909 t = parent.predicate("fhir:"+parentType+'.'+name); 1910 } 1911 composeDomainResource(t, "CareTeam", name, element, index); 1912 for (int i = 0; i < element.getIdentifier().size(); i++) 1913 composeIdentifier(t, "CareTeam", "identifier", element.getIdentifier().get(i), i); 1914 if (element.hasStatus()) 1915 composeCodeableConcept(t, "CareTeam", "status", element.getStatus(), -1); 1916 for (int i = 0; i < element.getType().size(); i++) 1917 composeCodeableConcept(t, "CareTeam", "type", element.getType().get(i), i); 1918 if (element.hasNameElement()) 1919 composeString(t, "CareTeam", "name", element.getNameElement(), -1); 1920 if (element.hasSubject()) 1921 composeReference(t, "CareTeam", "subject", element.getSubject(), -1); 1922 if (element.hasPeriod()) 1923 composePeriod(t, "CareTeam", "period", element.getPeriod(), -1); 1924 for (int i = 0; i < element.getParticipant().size(); i++) 1925 composeCareTeamCareTeamParticipantComponent(t, "CareTeam", "participant", element.getParticipant().get(i), i); 1926 if (element.hasManagingOrganization()) 1927 composeReference(t, "CareTeam", "managingOrganization", element.getManagingOrganization(), -1); 1928 } 1929 1930 protected void composeCareTeamCareTeamParticipantComponent(Complex parent, String parentType, String name, CareTeam.CareTeamParticipantComponent element, int index) { 1931 if (element == null) 1932 return; 1933 Complex t; 1934 if (Utilities.noString(parentType)) 1935 t = parent; 1936 else { 1937 t = parent.predicate("fhir:"+parentType+'.'+name); 1938 } 1939 composeBackboneElement(t, "participant", name, element, index); 1940 if (element.hasRole()) 1941 composeCodeableConcept(t, "CareTeam", "role", element.getRole(), -1); 1942 if (element.hasMember()) 1943 composeReference(t, "CareTeam", "member", element.getMember(), -1); 1944 if (element.hasPeriod()) 1945 composePeriod(t, "CareTeam", "period", element.getPeriod(), -1); 1946 } 1947 1948 protected void composeClaim(Complex parent, String parentType, String name, Claim element, int index) { 1949 if (element == null) 1950 return; 1951 Complex t; 1952 if (Utilities.noString(parentType)) 1953 t = parent; 1954 else { 1955 t = parent.predicate("fhir:"+parentType+'.'+name); 1956 } 1957 composeDomainResource(t, "Claim", name, element, index); 1958 if (element.hasTypeElement()) 1959 composeEnum(t, "Claim", "type", element.getTypeElement(), -1); 1960 for (int i = 0; i < element.getSubType().size(); i++) 1961 composeCoding(t, "Claim", "subType", element.getSubType().get(i), i); 1962 for (int i = 0; i < element.getIdentifier().size(); i++) 1963 composeIdentifier(t, "Claim", "identifier", element.getIdentifier().get(i), i); 1964 if (element.hasRuleset()) 1965 composeCoding(t, "Claim", "ruleset", element.getRuleset(), -1); 1966 if (element.hasOriginalRuleset()) 1967 composeCoding(t, "Claim", "originalRuleset", element.getOriginalRuleset(), -1); 1968 if (element.hasCreatedElement()) 1969 composeDateTime(t, "Claim", "created", element.getCreatedElement(), -1); 1970 if (element.hasBillablePeriod()) 1971 composePeriod(t, "Claim", "billablePeriod", element.getBillablePeriod(), -1); 1972 if (element.hasTarget()) 1973 composeType(t, "Claim", "target", element.getTarget(), -1); 1974 if (element.hasProvider()) 1975 composeType(t, "Claim", "provider", element.getProvider(), -1); 1976 if (element.hasOrganization()) 1977 composeType(t, "Claim", "organization", element.getOrganization(), -1); 1978 if (element.hasUseElement()) 1979 composeEnum(t, "Claim", "use", element.getUseElement(), -1); 1980 if (element.hasPriority()) 1981 composeCoding(t, "Claim", "priority", element.getPriority(), -1); 1982 if (element.hasFundsReserve()) 1983 composeCoding(t, "Claim", "fundsReserve", element.getFundsReserve(), -1); 1984 if (element.hasEnterer()) 1985 composeType(t, "Claim", "enterer", element.getEnterer(), -1); 1986 if (element.hasFacility()) 1987 composeType(t, "Claim", "facility", element.getFacility(), -1); 1988 for (int i = 0; i < element.getRelated().size(); i++) 1989 composeClaimRelatedClaimsComponent(t, "Claim", "related", element.getRelated().get(i), i); 1990 if (element.hasPrescription()) 1991 composeType(t, "Claim", "prescription", element.getPrescription(), -1); 1992 if (element.hasOriginalPrescription()) 1993 composeType(t, "Claim", "originalPrescription", element.getOriginalPrescription(), -1); 1994 if (element.hasPayee()) 1995 composeClaimPayeeComponent(t, "Claim", "payee", element.getPayee(), -1); 1996 if (element.hasReferral()) 1997 composeType(t, "Claim", "referral", element.getReferral(), -1); 1998 for (int i = 0; i < element.getOccurrenceCode().size(); i++) 1999 composeCoding(t, "Claim", "occurrenceCode", element.getOccurrenceCode().get(i), i); 2000 for (int i = 0; i < element.getOccurenceSpanCode().size(); i++) 2001 composeCoding(t, "Claim", "occurenceSpanCode", element.getOccurenceSpanCode().get(i), i); 2002 for (int i = 0; i < element.getValueCode().size(); i++) 2003 composeCoding(t, "Claim", "valueCode", element.getValueCode().get(i), i); 2004 for (int i = 0; i < element.getDiagnosis().size(); i++) 2005 composeClaimDiagnosisComponent(t, "Claim", "diagnosis", element.getDiagnosis().get(i), i); 2006 for (int i = 0; i < element.getProcedure().size(); i++) 2007 composeClaimProcedureComponent(t, "Claim", "procedure", element.getProcedure().get(i), i); 2008 for (int i = 0; i < element.getSpecialCondition().size(); i++) 2009 composeCoding(t, "Claim", "specialCondition", element.getSpecialCondition().get(i), i); 2010 if (element.hasPatient()) 2011 composeType(t, "Claim", "patient", element.getPatient(), -1); 2012 for (int i = 0; i < element.getCoverage().size(); i++) 2013 composeClaimCoverageComponent(t, "Claim", "coverage", element.getCoverage().get(i), i); 2014 if (element.hasAccidentDateElement()) 2015 composeDate(t, "Claim", "accidentDate", element.getAccidentDateElement(), -1); 2016 if (element.hasAccidentType()) 2017 composeCoding(t, "Claim", "accidentType", element.getAccidentType(), -1); 2018 if (element.hasAccidentLocation()) 2019 composeType(t, "Claim", "accidentLocation", element.getAccidentLocation(), -1); 2020 for (int i = 0; i < element.getInterventionException().size(); i++) 2021 composeCoding(t, "Claim", "interventionException", element.getInterventionException().get(i), i); 2022 for (int i = 0; i < element.getOnset().size(); i++) 2023 composeClaimOnsetComponent(t, "Claim", "onset", element.getOnset().get(i), i); 2024 if (element.hasEmploymentImpacted()) 2025 composePeriod(t, "Claim", "employmentImpacted", element.getEmploymentImpacted(), -1); 2026 if (element.hasHospitalization()) 2027 composePeriod(t, "Claim", "hospitalization", element.getHospitalization(), -1); 2028 for (int i = 0; i < element.getItem().size(); i++) 2029 composeClaimItemsComponent(t, "Claim", "item", element.getItem().get(i), i); 2030 if (element.hasTotal()) 2031 composeQuantity(t, "Claim", "total", element.getTotal(), -1); 2032 for (int i = 0; i < element.getAdditionalMaterial().size(); i++) 2033 composeCoding(t, "Claim", "additionalMaterial", element.getAdditionalMaterial().get(i), i); 2034 for (int i = 0; i < element.getMissingTeeth().size(); i++) 2035 composeClaimMissingTeethComponent(t, "Claim", "missingTeeth", element.getMissingTeeth().get(i), i); 2036 } 2037 2038 protected void composeClaimRelatedClaimsComponent(Complex parent, String parentType, String name, Claim.RelatedClaimsComponent element, int index) { 2039 if (element == null) 2040 return; 2041 Complex t; 2042 if (Utilities.noString(parentType)) 2043 t = parent; 2044 else { 2045 t = parent.predicate("fhir:"+parentType+'.'+name); 2046 } 2047 composeBackboneElement(t, "related", name, element, index); 2048 if (element.hasClaim()) 2049 composeType(t, "Claim", "claim", element.getClaim(), -1); 2050 if (element.hasRelationship()) 2051 composeCoding(t, "Claim", "relationship", element.getRelationship(), -1); 2052 if (element.hasReference()) 2053 composeIdentifier(t, "Claim", "reference", element.getReference(), -1); 2054 } 2055 2056 protected void composeClaimPayeeComponent(Complex parent, String parentType, String name, Claim.PayeeComponent element, int index) { 2057 if (element == null) 2058 return; 2059 Complex t; 2060 if (Utilities.noString(parentType)) 2061 t = parent; 2062 else { 2063 t = parent.predicate("fhir:"+parentType+'.'+name); 2064 } 2065 composeBackboneElement(t, "payee", name, element, index); 2066 if (element.hasType()) 2067 composeCoding(t, "Claim", "type", element.getType(), -1); 2068 if (element.hasParty()) 2069 composeType(t, "Claim", "party", element.getParty(), -1); 2070 } 2071 2072 protected void composeClaimDiagnosisComponent(Complex parent, String parentType, String name, Claim.DiagnosisComponent element, int index) { 2073 if (element == null) 2074 return; 2075 Complex t; 2076 if (Utilities.noString(parentType)) 2077 t = parent; 2078 else { 2079 t = parent.predicate("fhir:"+parentType+'.'+name); 2080 } 2081 composeBackboneElement(t, "diagnosis", name, element, index); 2082 if (element.hasSequenceElement()) 2083 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2084 if (element.hasDiagnosis()) 2085 composeCoding(t, "Claim", "diagnosis", element.getDiagnosis(), -1); 2086 } 2087 2088 protected void composeClaimProcedureComponent(Complex parent, String parentType, String name, Claim.ProcedureComponent element, int index) { 2089 if (element == null) 2090 return; 2091 Complex t; 2092 if (Utilities.noString(parentType)) 2093 t = parent; 2094 else { 2095 t = parent.predicate("fhir:"+parentType+'.'+name); 2096 } 2097 composeBackboneElement(t, "procedure", name, element, index); 2098 if (element.hasSequenceElement()) 2099 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2100 if (element.hasDateElement()) 2101 composeDateTime(t, "Claim", "date", element.getDateElement(), -1); 2102 if (element.hasProcedure()) 2103 composeType(t, "Claim", "procedure", element.getProcedure(), -1); 2104 } 2105 2106 protected void composeClaimCoverageComponent(Complex parent, String parentType, String name, Claim.CoverageComponent element, int index) { 2107 if (element == null) 2108 return; 2109 Complex t; 2110 if (Utilities.noString(parentType)) 2111 t = parent; 2112 else { 2113 t = parent.predicate("fhir:"+parentType+'.'+name); 2114 } 2115 composeBackboneElement(t, "coverage", name, element, index); 2116 if (element.hasSequenceElement()) 2117 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2118 if (element.hasFocalElement()) 2119 composeBoolean(t, "Claim", "focal", element.getFocalElement(), -1); 2120 if (element.hasCoverage()) 2121 composeType(t, "Claim", "coverage", element.getCoverage(), -1); 2122 if (element.hasBusinessArrangementElement()) 2123 composeString(t, "Claim", "businessArrangement", element.getBusinessArrangementElement(), -1); 2124 for (int i = 0; i < element.getPreAuthRef().size(); i++) 2125 composeString(t, "Claim", "preAuthRef", element.getPreAuthRef().get(i), i); 2126 if (element.hasClaimResponse()) 2127 composeReference(t, "Claim", "claimResponse", element.getClaimResponse(), -1); 2128 if (element.hasOriginalRuleset()) 2129 composeCoding(t, "Claim", "originalRuleset", element.getOriginalRuleset(), -1); 2130 } 2131 2132 protected void composeClaimOnsetComponent(Complex parent, String parentType, String name, Claim.OnsetComponent element, int index) { 2133 if (element == null) 2134 return; 2135 Complex t; 2136 if (Utilities.noString(parentType)) 2137 t = parent; 2138 else { 2139 t = parent.predicate("fhir:"+parentType+'.'+name); 2140 } 2141 composeBackboneElement(t, "onset", name, element, index); 2142 if (element.hasTime()) 2143 composeType(t, "Claim", "time", element.getTime(), -1); 2144 if (element.hasType()) 2145 composeCoding(t, "Claim", "type", element.getType(), -1); 2146 } 2147 2148 protected void composeClaimItemsComponent(Complex parent, String parentType, String name, Claim.ItemsComponent element, int index) { 2149 if (element == null) 2150 return; 2151 Complex t; 2152 if (Utilities.noString(parentType)) 2153 t = parent; 2154 else { 2155 t = parent.predicate("fhir:"+parentType+'.'+name); 2156 } 2157 composeBackboneElement(t, "item", name, element, index); 2158 if (element.hasSequenceElement()) 2159 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2160 if (element.hasType()) 2161 composeCoding(t, "Claim", "type", element.getType(), -1); 2162 if (element.hasProvider()) 2163 composeType(t, "Claim", "provider", element.getProvider(), -1); 2164 if (element.hasSupervisor()) 2165 composeType(t, "Claim", "supervisor", element.getSupervisor(), -1); 2166 if (element.hasProviderQualification()) 2167 composeCoding(t, "Claim", "providerQualification", element.getProviderQualification(), -1); 2168 for (int i = 0; i < element.getDiagnosisLinkId().size(); i++) 2169 composePositiveInt(t, "Claim", "diagnosisLinkId", element.getDiagnosisLinkId().get(i), i); 2170 if (element.hasService()) 2171 composeCoding(t, "Claim", "service", element.getService(), -1); 2172 for (int i = 0; i < element.getServiceModifier().size(); i++) 2173 composeCoding(t, "Claim", "serviceModifier", element.getServiceModifier().get(i), i); 2174 for (int i = 0; i < element.getModifier().size(); i++) 2175 composeCoding(t, "Claim", "modifier", element.getModifier().get(i), i); 2176 for (int i = 0; i < element.getProgramCode().size(); i++) 2177 composeCoding(t, "Claim", "programCode", element.getProgramCode().get(i), i); 2178 if (element.hasServiced()) 2179 composeType(t, "Claim", "serviced", element.getServiced(), -1); 2180 if (element.hasPlace()) 2181 composeCoding(t, "Claim", "place", element.getPlace(), -1); 2182 if (element.hasQuantity()) 2183 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 2184 if (element.hasUnitPrice()) 2185 composeQuantity(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 2186 if (element.hasFactorElement()) 2187 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 2188 if (element.hasPointsElement()) 2189 composeDecimal(t, "Claim", "points", element.getPointsElement(), -1); 2190 if (element.hasNet()) 2191 composeQuantity(t, "Claim", "net", element.getNet(), -1); 2192 for (int i = 0; i < element.getUdi().size(); i++) 2193 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 2194 if (element.hasBodySite()) 2195 composeCoding(t, "Claim", "bodySite", element.getBodySite(), -1); 2196 for (int i = 0; i < element.getSubSite().size(); i++) 2197 composeCoding(t, "Claim", "subSite", element.getSubSite().get(i), i); 2198 for (int i = 0; i < element.getDetail().size(); i++) 2199 composeClaimDetailComponent(t, "Claim", "detail", element.getDetail().get(i), i); 2200 if (element.hasProsthesis()) 2201 composeClaimProsthesisComponent(t, "Claim", "prosthesis", element.getProsthesis(), -1); 2202 } 2203 2204 protected void composeClaimDetailComponent(Complex parent, String parentType, String name, Claim.DetailComponent element, int index) { 2205 if (element == null) 2206 return; 2207 Complex t; 2208 if (Utilities.noString(parentType)) 2209 t = parent; 2210 else { 2211 t = parent.predicate("fhir:"+parentType+'.'+name); 2212 } 2213 composeBackboneElement(t, "detail", name, element, index); 2214 if (element.hasSequenceElement()) 2215 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2216 if (element.hasType()) 2217 composeCoding(t, "Claim", "type", element.getType(), -1); 2218 if (element.hasService()) 2219 composeCoding(t, "Claim", "service", element.getService(), -1); 2220 for (int i = 0; i < element.getProgramCode().size(); i++) 2221 composeCoding(t, "Claim", "programCode", element.getProgramCode().get(i), i); 2222 if (element.hasQuantity()) 2223 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 2224 if (element.hasUnitPrice()) 2225 composeQuantity(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 2226 if (element.hasFactorElement()) 2227 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 2228 if (element.hasPointsElement()) 2229 composeDecimal(t, "Claim", "points", element.getPointsElement(), -1); 2230 if (element.hasNet()) 2231 composeQuantity(t, "Claim", "net", element.getNet(), -1); 2232 for (int i = 0; i < element.getUdi().size(); i++) 2233 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 2234 for (int i = 0; i < element.getSubDetail().size(); i++) 2235 composeClaimSubDetailComponent(t, "Claim", "subDetail", element.getSubDetail().get(i), i); 2236 } 2237 2238 protected void composeClaimSubDetailComponent(Complex parent, String parentType, String name, Claim.SubDetailComponent element, int index) { 2239 if (element == null) 2240 return; 2241 Complex t; 2242 if (Utilities.noString(parentType)) 2243 t = parent; 2244 else { 2245 t = parent.predicate("fhir:"+parentType+'.'+name); 2246 } 2247 composeBackboneElement(t, "subDetail", name, element, index); 2248 if (element.hasSequenceElement()) 2249 composePositiveInt(t, "Claim", "sequence", element.getSequenceElement(), -1); 2250 if (element.hasType()) 2251 composeCoding(t, "Claim", "type", element.getType(), -1); 2252 if (element.hasService()) 2253 composeCoding(t, "Claim", "service", element.getService(), -1); 2254 for (int i = 0; i < element.getProgramCode().size(); i++) 2255 composeCoding(t, "Claim", "programCode", element.getProgramCode().get(i), i); 2256 if (element.hasQuantity()) 2257 composeQuantity(t, "Claim", "quantity", element.getQuantity(), -1); 2258 if (element.hasUnitPrice()) 2259 composeQuantity(t, "Claim", "unitPrice", element.getUnitPrice(), -1); 2260 if (element.hasFactorElement()) 2261 composeDecimal(t, "Claim", "factor", element.getFactorElement(), -1); 2262 if (element.hasPointsElement()) 2263 composeDecimal(t, "Claim", "points", element.getPointsElement(), -1); 2264 if (element.hasNet()) 2265 composeQuantity(t, "Claim", "net", element.getNet(), -1); 2266 for (int i = 0; i < element.getUdi().size(); i++) 2267 composeReference(t, "Claim", "udi", element.getUdi().get(i), i); 2268 } 2269 2270 protected void composeClaimProsthesisComponent(Complex parent, String parentType, String name, Claim.ProsthesisComponent element, int index) { 2271 if (element == null) 2272 return; 2273 Complex t; 2274 if (Utilities.noString(parentType)) 2275 t = parent; 2276 else { 2277 t = parent.predicate("fhir:"+parentType+'.'+name); 2278 } 2279 composeBackboneElement(t, "prosthesis", name, element, index); 2280 if (element.hasInitialElement()) 2281 composeBoolean(t, "Claim", "initial", element.getInitialElement(), -1); 2282 if (element.hasPriorDateElement()) 2283 composeDate(t, "Claim", "priorDate", element.getPriorDateElement(), -1); 2284 if (element.hasPriorMaterial()) 2285 composeCoding(t, "Claim", "priorMaterial", element.getPriorMaterial(), -1); 2286 } 2287 2288 protected void composeClaimMissingTeethComponent(Complex parent, String parentType, String name, Claim.MissingTeethComponent element, int index) { 2289 if (element == null) 2290 return; 2291 Complex t; 2292 if (Utilities.noString(parentType)) 2293 t = parent; 2294 else { 2295 t = parent.predicate("fhir:"+parentType+'.'+name); 2296 } 2297 composeBackboneElement(t, "missingTeeth", name, element, index); 2298 if (element.hasTooth()) 2299 composeCoding(t, "Claim", "tooth", element.getTooth(), -1); 2300 if (element.hasReason()) 2301 composeCoding(t, "Claim", "reason", element.getReason(), -1); 2302 if (element.hasExtractionDateElement()) 2303 composeDate(t, "Claim", "extractionDate", element.getExtractionDateElement(), -1); 2304 } 2305 2306 protected void composeClaimResponse(Complex parent, String parentType, String name, ClaimResponse element, int index) { 2307 if (element == null) 2308 return; 2309 Complex t; 2310 if (Utilities.noString(parentType)) 2311 t = parent; 2312 else { 2313 t = parent.predicate("fhir:"+parentType+'.'+name); 2314 } 2315 composeDomainResource(t, "ClaimResponse", name, element, index); 2316 for (int i = 0; i < element.getIdentifier().size(); i++) 2317 composeIdentifier(t, "ClaimResponse", "identifier", element.getIdentifier().get(i), i); 2318 if (element.hasRequest()) 2319 composeType(t, "ClaimResponse", "request", element.getRequest(), -1); 2320 if (element.hasRuleset()) 2321 composeCoding(t, "ClaimResponse", "ruleset", element.getRuleset(), -1); 2322 if (element.hasOriginalRuleset()) 2323 composeCoding(t, "ClaimResponse", "originalRuleset", element.getOriginalRuleset(), -1); 2324 if (element.hasCreatedElement()) 2325 composeDateTime(t, "ClaimResponse", "created", element.getCreatedElement(), -1); 2326 if (element.hasOrganization()) 2327 composeType(t, "ClaimResponse", "organization", element.getOrganization(), -1); 2328 if (element.hasRequestProvider()) 2329 composeType(t, "ClaimResponse", "requestProvider", element.getRequestProvider(), -1); 2330 if (element.hasRequestOrganization()) 2331 composeType(t, "ClaimResponse", "requestOrganization", element.getRequestOrganization(), -1); 2332 if (element.hasOutcomeElement()) 2333 composeEnum(t, "ClaimResponse", "outcome", element.getOutcomeElement(), -1); 2334 if (element.hasDispositionElement()) 2335 composeString(t, "ClaimResponse", "disposition", element.getDispositionElement(), -1); 2336 if (element.hasPayeeType()) 2337 composeCoding(t, "ClaimResponse", "payeeType", element.getPayeeType(), -1); 2338 for (int i = 0; i < element.getItem().size(); i++) 2339 composeClaimResponseItemsComponent(t, "ClaimResponse", "item", element.getItem().get(i), i); 2340 for (int i = 0; i < element.getAddItem().size(); i++) 2341 composeClaimResponseAddedItemComponent(t, "ClaimResponse", "addItem", element.getAddItem().get(i), i); 2342 for (int i = 0; i < element.getError().size(); i++) 2343 composeClaimResponseErrorsComponent(t, "ClaimResponse", "error", element.getError().get(i), i); 2344 if (element.hasTotalCost()) 2345 composeQuantity(t, "ClaimResponse", "totalCost", element.getTotalCost(), -1); 2346 if (element.hasUnallocDeductable()) 2347 composeQuantity(t, "ClaimResponse", "unallocDeductable", element.getUnallocDeductable(), -1); 2348 if (element.hasTotalBenefit()) 2349 composeQuantity(t, "ClaimResponse", "totalBenefit", element.getTotalBenefit(), -1); 2350 if (element.hasPaymentAdjustment()) 2351 composeQuantity(t, "ClaimResponse", "paymentAdjustment", element.getPaymentAdjustment(), -1); 2352 if (element.hasPaymentAdjustmentReason()) 2353 composeCoding(t, "ClaimResponse", "paymentAdjustmentReason", element.getPaymentAdjustmentReason(), -1); 2354 if (element.hasPaymentDateElement()) 2355 composeDate(t, "ClaimResponse", "paymentDate", element.getPaymentDateElement(), -1); 2356 if (element.hasPaymentAmount()) 2357 composeQuantity(t, "ClaimResponse", "paymentAmount", element.getPaymentAmount(), -1); 2358 if (element.hasPaymentRef()) 2359 composeIdentifier(t, "ClaimResponse", "paymentRef", element.getPaymentRef(), -1); 2360 if (element.hasReserved()) 2361 composeCoding(t, "ClaimResponse", "reserved", element.getReserved(), -1); 2362 if (element.hasForm()) 2363 composeCoding(t, "ClaimResponse", "form", element.getForm(), -1); 2364 for (int i = 0; i < element.getNote().size(); i++) 2365 composeClaimResponseNotesComponent(t, "ClaimResponse", "note", element.getNote().get(i), i); 2366 for (int i = 0; i < element.getCoverage().size(); i++) 2367 composeClaimResponseCoverageComponent(t, "ClaimResponse", "coverage", element.getCoverage().get(i), i); 2368 } 2369 2370 protected void composeClaimResponseItemsComponent(Complex parent, String parentType, String name, ClaimResponse.ItemsComponent element, int index) { 2371 if (element == null) 2372 return; 2373 Complex t; 2374 if (Utilities.noString(parentType)) 2375 t = parent; 2376 else { 2377 t = parent.predicate("fhir:"+parentType+'.'+name); 2378 } 2379 composeBackboneElement(t, "item", name, element, index); 2380 if (element.hasSequenceLinkIdElement()) 2381 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 2382 for (int i = 0; i < element.getNoteNumber().size(); i++) 2383 composePositiveInt(t, "ClaimResponse", "noteNumber", element.getNoteNumber().get(i), i); 2384 for (int i = 0; i < element.getAdjudication().size(); i++) 2385 composeClaimResponseItemAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 2386 for (int i = 0; i < element.getDetail().size(); i++) 2387 composeClaimResponseItemDetailComponent(t, "ClaimResponse", "detail", element.getDetail().get(i), i); 2388 } 2389 2390 protected void composeClaimResponseItemAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.ItemAdjudicationComponent element, int index) { 2391 if (element == null) 2392 return; 2393 Complex t; 2394 if (Utilities.noString(parentType)) 2395 t = parent; 2396 else { 2397 t = parent.predicate("fhir:"+parentType+'.'+name); 2398 } 2399 composeBackboneElement(t, "adjudication", name, element, index); 2400 if (element.hasCategory()) 2401 composeCoding(t, "ClaimResponse", "category", element.getCategory(), -1); 2402 if (element.hasReason()) 2403 composeCoding(t, "ClaimResponse", "reason", element.getReason(), -1); 2404 if (element.hasAmount()) 2405 composeQuantity(t, "ClaimResponse", "amount", element.getAmount(), -1); 2406 if (element.hasValueElement()) 2407 composeDecimal(t, "ClaimResponse", "value", element.getValueElement(), -1); 2408 } 2409 2410 protected void composeClaimResponseItemDetailComponent(Complex parent, String parentType, String name, ClaimResponse.ItemDetailComponent element, int index) { 2411 if (element == null) 2412 return; 2413 Complex t; 2414 if (Utilities.noString(parentType)) 2415 t = parent; 2416 else { 2417 t = parent.predicate("fhir:"+parentType+'.'+name); 2418 } 2419 composeBackboneElement(t, "detail", name, element, index); 2420 if (element.hasSequenceLinkIdElement()) 2421 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 2422 for (int i = 0; i < element.getAdjudication().size(); i++) 2423 composeClaimResponseDetailAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 2424 for (int i = 0; i < element.getSubDetail().size(); i++) 2425 composeClaimResponseSubDetailComponent(t, "ClaimResponse", "subDetail", element.getSubDetail().get(i), i); 2426 } 2427 2428 protected void composeClaimResponseDetailAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.DetailAdjudicationComponent element, int index) { 2429 if (element == null) 2430 return; 2431 Complex t; 2432 if (Utilities.noString(parentType)) 2433 t = parent; 2434 else { 2435 t = parent.predicate("fhir:"+parentType+'.'+name); 2436 } 2437 composeBackboneElement(t, "adjudication", name, element, index); 2438 if (element.hasCategory()) 2439 composeCoding(t, "ClaimResponse", "category", element.getCategory(), -1); 2440 if (element.hasReason()) 2441 composeCoding(t, "ClaimResponse", "reason", element.getReason(), -1); 2442 if (element.hasAmount()) 2443 composeQuantity(t, "ClaimResponse", "amount", element.getAmount(), -1); 2444 if (element.hasValueElement()) 2445 composeDecimal(t, "ClaimResponse", "value", element.getValueElement(), -1); 2446 } 2447 2448 protected void composeClaimResponseSubDetailComponent(Complex parent, String parentType, String name, ClaimResponse.SubDetailComponent element, int index) { 2449 if (element == null) 2450 return; 2451 Complex t; 2452 if (Utilities.noString(parentType)) 2453 t = parent; 2454 else { 2455 t = parent.predicate("fhir:"+parentType+'.'+name); 2456 } 2457 composeBackboneElement(t, "subDetail", name, element, index); 2458 if (element.hasSequenceLinkIdElement()) 2459 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 2460 for (int i = 0; i < element.getAdjudication().size(); i++) 2461 composeClaimResponseSubdetailAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 2462 } 2463 2464 protected void composeClaimResponseSubdetailAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.SubdetailAdjudicationComponent element, int index) { 2465 if (element == null) 2466 return; 2467 Complex t; 2468 if (Utilities.noString(parentType)) 2469 t = parent; 2470 else { 2471 t = parent.predicate("fhir:"+parentType+'.'+name); 2472 } 2473 composeBackboneElement(t, "adjudication", name, element, index); 2474 if (element.hasCategory()) 2475 composeCoding(t, "ClaimResponse", "category", element.getCategory(), -1); 2476 if (element.hasReason()) 2477 composeCoding(t, "ClaimResponse", "reason", element.getReason(), -1); 2478 if (element.hasAmount()) 2479 composeQuantity(t, "ClaimResponse", "amount", element.getAmount(), -1); 2480 if (element.hasValueElement()) 2481 composeDecimal(t, "ClaimResponse", "value", element.getValueElement(), -1); 2482 } 2483 2484 protected void composeClaimResponseAddedItemComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemComponent element, int index) { 2485 if (element == null) 2486 return; 2487 Complex t; 2488 if (Utilities.noString(parentType)) 2489 t = parent; 2490 else { 2491 t = parent.predicate("fhir:"+parentType+'.'+name); 2492 } 2493 composeBackboneElement(t, "addItem", name, element, index); 2494 for (int i = 0; i < element.getSequenceLinkId().size(); i++) 2495 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkId().get(i), i); 2496 if (element.hasService()) 2497 composeCoding(t, "ClaimResponse", "service", element.getService(), -1); 2498 if (element.hasFee()) 2499 composeQuantity(t, "ClaimResponse", "fee", element.getFee(), -1); 2500 for (int i = 0; i < element.getNoteNumberLinkId().size(); i++) 2501 composePositiveInt(t, "ClaimResponse", "noteNumberLinkId", element.getNoteNumberLinkId().get(i), i); 2502 for (int i = 0; i < element.getAdjudication().size(); i++) 2503 composeClaimResponseAddedItemAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 2504 for (int i = 0; i < element.getDetail().size(); i++) 2505 composeClaimResponseAddedItemsDetailComponent(t, "ClaimResponse", "detail", element.getDetail().get(i), i); 2506 } 2507 2508 protected void composeClaimResponseAddedItemAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemAdjudicationComponent element, int index) { 2509 if (element == null) 2510 return; 2511 Complex t; 2512 if (Utilities.noString(parentType)) 2513 t = parent; 2514 else { 2515 t = parent.predicate("fhir:"+parentType+'.'+name); 2516 } 2517 composeBackboneElement(t, "adjudication", name, element, index); 2518 if (element.hasCategory()) 2519 composeCoding(t, "ClaimResponse", "category", element.getCategory(), -1); 2520 if (element.hasReason()) 2521 composeCoding(t, "ClaimResponse", "reason", element.getReason(), -1); 2522 if (element.hasAmount()) 2523 composeQuantity(t, "ClaimResponse", "amount", element.getAmount(), -1); 2524 if (element.hasValueElement()) 2525 composeDecimal(t, "ClaimResponse", "value", element.getValueElement(), -1); 2526 } 2527 2528 protected void composeClaimResponseAddedItemsDetailComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemsDetailComponent element, int index) { 2529 if (element == null) 2530 return; 2531 Complex t; 2532 if (Utilities.noString(parentType)) 2533 t = parent; 2534 else { 2535 t = parent.predicate("fhir:"+parentType+'.'+name); 2536 } 2537 composeBackboneElement(t, "detail", name, element, index); 2538 if (element.hasService()) 2539 composeCoding(t, "ClaimResponse", "service", element.getService(), -1); 2540 if (element.hasFee()) 2541 composeQuantity(t, "ClaimResponse", "fee", element.getFee(), -1); 2542 for (int i = 0; i < element.getAdjudication().size(); i++) 2543 composeClaimResponseAddedItemDetailAdjudicationComponent(t, "ClaimResponse", "adjudication", element.getAdjudication().get(i), i); 2544 } 2545 2546 protected void composeClaimResponseAddedItemDetailAdjudicationComponent(Complex parent, String parentType, String name, ClaimResponse.AddedItemDetailAdjudicationComponent element, int index) { 2547 if (element == null) 2548 return; 2549 Complex t; 2550 if (Utilities.noString(parentType)) 2551 t = parent; 2552 else { 2553 t = parent.predicate("fhir:"+parentType+'.'+name); 2554 } 2555 composeBackboneElement(t, "adjudication", name, element, index); 2556 if (element.hasCategory()) 2557 composeCoding(t, "ClaimResponse", "category", element.getCategory(), -1); 2558 if (element.hasReason()) 2559 composeCoding(t, "ClaimResponse", "reason", element.getReason(), -1); 2560 if (element.hasAmount()) 2561 composeQuantity(t, "ClaimResponse", "amount", element.getAmount(), -1); 2562 if (element.hasValueElement()) 2563 composeDecimal(t, "ClaimResponse", "value", element.getValueElement(), -1); 2564 } 2565 2566 protected void composeClaimResponseErrorsComponent(Complex parent, String parentType, String name, ClaimResponse.ErrorsComponent element, int index) { 2567 if (element == null) 2568 return; 2569 Complex t; 2570 if (Utilities.noString(parentType)) 2571 t = parent; 2572 else { 2573 t = parent.predicate("fhir:"+parentType+'.'+name); 2574 } 2575 composeBackboneElement(t, "error", name, element, index); 2576 if (element.hasSequenceLinkIdElement()) 2577 composePositiveInt(t, "ClaimResponse", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 2578 if (element.hasDetailSequenceLinkIdElement()) 2579 composePositiveInt(t, "ClaimResponse", "detailSequenceLinkId", element.getDetailSequenceLinkIdElement(), -1); 2580 if (element.hasSubdetailSequenceLinkIdElement()) 2581 composePositiveInt(t, "ClaimResponse", "subdetailSequenceLinkId", element.getSubdetailSequenceLinkIdElement(), -1); 2582 if (element.hasCode()) 2583 composeCoding(t, "ClaimResponse", "code", element.getCode(), -1); 2584 } 2585 2586 protected void composeClaimResponseNotesComponent(Complex parent, String parentType, String name, ClaimResponse.NotesComponent element, int index) { 2587 if (element == null) 2588 return; 2589 Complex t; 2590 if (Utilities.noString(parentType)) 2591 t = parent; 2592 else { 2593 t = parent.predicate("fhir:"+parentType+'.'+name); 2594 } 2595 composeBackboneElement(t, "note", name, element, index); 2596 if (element.hasNumberElement()) 2597 composePositiveInt(t, "ClaimResponse", "number", element.getNumberElement(), -1); 2598 if (element.hasType()) 2599 composeCoding(t, "ClaimResponse", "type", element.getType(), -1); 2600 if (element.hasTextElement()) 2601 composeString(t, "ClaimResponse", "text", element.getTextElement(), -1); 2602 } 2603 2604 protected void composeClaimResponseCoverageComponent(Complex parent, String parentType, String name, ClaimResponse.CoverageComponent element, int index) { 2605 if (element == null) 2606 return; 2607 Complex t; 2608 if (Utilities.noString(parentType)) 2609 t = parent; 2610 else { 2611 t = parent.predicate("fhir:"+parentType+'.'+name); 2612 } 2613 composeBackboneElement(t, "coverage", name, element, index); 2614 if (element.hasSequenceElement()) 2615 composePositiveInt(t, "ClaimResponse", "sequence", element.getSequenceElement(), -1); 2616 if (element.hasFocalElement()) 2617 composeBoolean(t, "ClaimResponse", "focal", element.getFocalElement(), -1); 2618 if (element.hasCoverage()) 2619 composeType(t, "ClaimResponse", "coverage", element.getCoverage(), -1); 2620 if (element.hasBusinessArrangementElement()) 2621 composeString(t, "ClaimResponse", "businessArrangement", element.getBusinessArrangementElement(), -1); 2622 for (int i = 0; i < element.getPreAuthRef().size(); i++) 2623 composeString(t, "ClaimResponse", "preAuthRef", element.getPreAuthRef().get(i), i); 2624 if (element.hasClaimResponse()) 2625 composeReference(t, "ClaimResponse", "claimResponse", element.getClaimResponse(), -1); 2626 } 2627 2628 protected void composeClinicalImpression(Complex parent, String parentType, String name, ClinicalImpression element, int index) { 2629 if (element == null) 2630 return; 2631 Complex t; 2632 if (Utilities.noString(parentType)) 2633 t = parent; 2634 else { 2635 t = parent.predicate("fhir:"+parentType+'.'+name); 2636 } 2637 composeDomainResource(t, "ClinicalImpression", name, element, index); 2638 if (element.hasPatient()) 2639 composeReference(t, "ClinicalImpression", "patient", element.getPatient(), -1); 2640 if (element.hasAssessor()) 2641 composeReference(t, "ClinicalImpression", "assessor", element.getAssessor(), -1); 2642 if (element.hasStatusElement()) 2643 composeEnum(t, "ClinicalImpression", "status", element.getStatusElement(), -1); 2644 if (element.hasDateElement()) 2645 composeDateTime(t, "ClinicalImpression", "date", element.getDateElement(), -1); 2646 if (element.hasDescriptionElement()) 2647 composeString(t, "ClinicalImpression", "description", element.getDescriptionElement(), -1); 2648 if (element.hasPrevious()) 2649 composeReference(t, "ClinicalImpression", "previous", element.getPrevious(), -1); 2650 for (int i = 0; i < element.getProblem().size(); i++) 2651 composeReference(t, "ClinicalImpression", "problem", element.getProblem().get(i), i); 2652 if (element.hasTrigger()) 2653 composeType(t, "ClinicalImpression", "trigger", element.getTrigger(), -1); 2654 for (int i = 0; i < element.getInvestigations().size(); i++) 2655 composeClinicalImpressionClinicalImpressionInvestigationsComponent(t, "ClinicalImpression", "investigations", element.getInvestigations().get(i), i); 2656 if (element.hasProtocolElement()) 2657 composeUri(t, "ClinicalImpression", "protocol", element.getProtocolElement(), -1); 2658 if (element.hasSummaryElement()) 2659 composeString(t, "ClinicalImpression", "summary", element.getSummaryElement(), -1); 2660 for (int i = 0; i < element.getFinding().size(); i++) 2661 composeClinicalImpressionClinicalImpressionFindingComponent(t, "ClinicalImpression", "finding", element.getFinding().get(i), i); 2662 for (int i = 0; i < element.getResolved().size(); i++) 2663 composeCodeableConcept(t, "ClinicalImpression", "resolved", element.getResolved().get(i), i); 2664 for (int i = 0; i < element.getRuledOut().size(); i++) 2665 composeClinicalImpressionClinicalImpressionRuledOutComponent(t, "ClinicalImpression", "ruledOut", element.getRuledOut().get(i), i); 2666 if (element.hasPrognosisElement()) 2667 composeString(t, "ClinicalImpression", "prognosis", element.getPrognosisElement(), -1); 2668 for (int i = 0; i < element.getPlan().size(); i++) 2669 composeReference(t, "ClinicalImpression", "plan", element.getPlan().get(i), i); 2670 for (int i = 0; i < element.getAction().size(); i++) 2671 composeReference(t, "ClinicalImpression", "action", element.getAction().get(i), i); 2672 } 2673 2674 protected void composeClinicalImpressionClinicalImpressionInvestigationsComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionInvestigationsComponent element, int index) { 2675 if (element == null) 2676 return; 2677 Complex t; 2678 if (Utilities.noString(parentType)) 2679 t = parent; 2680 else { 2681 t = parent.predicate("fhir:"+parentType+'.'+name); 2682 } 2683 composeBackboneElement(t, "investigations", name, element, index); 2684 if (element.hasCode()) 2685 composeCodeableConcept(t, "ClinicalImpression", "code", element.getCode(), -1); 2686 for (int i = 0; i < element.getItem().size(); i++) 2687 composeReference(t, "ClinicalImpression", "item", element.getItem().get(i), i); 2688 } 2689 2690 protected void composeClinicalImpressionClinicalImpressionFindingComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionFindingComponent element, int index) { 2691 if (element == null) 2692 return; 2693 Complex t; 2694 if (Utilities.noString(parentType)) 2695 t = parent; 2696 else { 2697 t = parent.predicate("fhir:"+parentType+'.'+name); 2698 } 2699 composeBackboneElement(t, "finding", name, element, index); 2700 if (element.hasItem()) 2701 composeCodeableConcept(t, "ClinicalImpression", "item", element.getItem(), -1); 2702 if (element.hasCauseElement()) 2703 composeString(t, "ClinicalImpression", "cause", element.getCauseElement(), -1); 2704 } 2705 2706 protected void composeClinicalImpressionClinicalImpressionRuledOutComponent(Complex parent, String parentType, String name, ClinicalImpression.ClinicalImpressionRuledOutComponent element, int index) { 2707 if (element == null) 2708 return; 2709 Complex t; 2710 if (Utilities.noString(parentType)) 2711 t = parent; 2712 else { 2713 t = parent.predicate("fhir:"+parentType+'.'+name); 2714 } 2715 composeBackboneElement(t, "ruledOut", name, element, index); 2716 if (element.hasItem()) 2717 composeCodeableConcept(t, "ClinicalImpression", "item", element.getItem(), -1); 2718 if (element.hasReasonElement()) 2719 composeString(t, "ClinicalImpression", "reason", element.getReasonElement(), -1); 2720 } 2721 2722 protected void composeCodeSystem(Complex parent, String parentType, String name, CodeSystem element, int index) { 2723 if (element == null) 2724 return; 2725 Complex t; 2726 if (Utilities.noString(parentType)) 2727 t = parent; 2728 else { 2729 t = parent.predicate("fhir:"+parentType+'.'+name); 2730 } 2731 composeDomainResource(t, "CodeSystem", name, element, index); 2732 if (element.hasUrlElement()) 2733 composeUri(t, "CodeSystem", "url", element.getUrlElement(), -1); 2734 if (element.hasIdentifier()) 2735 composeIdentifier(t, "CodeSystem", "identifier", element.getIdentifier(), -1); 2736 if (element.hasVersionElement()) 2737 composeString(t, "CodeSystem", "version", element.getVersionElement(), -1); 2738 if (element.hasNameElement()) 2739 composeString(t, "CodeSystem", "name", element.getNameElement(), -1); 2740 if (element.hasStatusElement()) 2741 composeEnum(t, "CodeSystem", "status", element.getStatusElement(), -1); 2742 if (element.hasExperimentalElement()) 2743 composeBoolean(t, "CodeSystem", "experimental", element.getExperimentalElement(), -1); 2744 if (element.hasPublisherElement()) 2745 composeString(t, "CodeSystem", "publisher", element.getPublisherElement(), -1); 2746 for (int i = 0; i < element.getContact().size(); i++) 2747 composeCodeSystemCodeSystemContactComponent(t, "CodeSystem", "contact", element.getContact().get(i), i); 2748 if (element.hasDateElement()) 2749 composeDateTime(t, "CodeSystem", "date", element.getDateElement(), -1); 2750 if (element.hasDescriptionElement()) 2751 composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 2752 for (int i = 0; i < element.getUseContext().size(); i++) 2753 composeCodeableConcept(t, "CodeSystem", "useContext", element.getUseContext().get(i), i); 2754 if (element.hasRequirementsElement()) 2755 composeString(t, "CodeSystem", "requirements", element.getRequirementsElement(), -1); 2756 if (element.hasCopyrightElement()) 2757 composeString(t, "CodeSystem", "copyright", element.getCopyrightElement(), -1); 2758 if (element.hasCaseSensitiveElement()) 2759 composeBoolean(t, "CodeSystem", "caseSensitive", element.getCaseSensitiveElement(), -1); 2760 if (element.hasValueSetElement()) 2761 composeUri(t, "CodeSystem", "valueSet", element.getValueSetElement(), -1); 2762 if (element.hasCompositionalElement()) 2763 composeBoolean(t, "CodeSystem", "compositional", element.getCompositionalElement(), -1); 2764 if (element.hasVersionNeededElement()) 2765 composeBoolean(t, "CodeSystem", "versionNeeded", element.getVersionNeededElement(), -1); 2766 if (element.hasContentElement()) 2767 composeEnum(t, "CodeSystem", "content", element.getContentElement(), -1); 2768 if (element.hasCountElement()) 2769 composeUnsignedInt(t, "CodeSystem", "count", element.getCountElement(), -1); 2770 for (int i = 0; i < element.getFilter().size(); i++) 2771 composeCodeSystemCodeSystemFilterComponent(t, "CodeSystem", "filter", element.getFilter().get(i), i); 2772 for (int i = 0; i < element.getProperty().size(); i++) 2773 composeCodeSystemCodeSystemPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i); 2774 for (int i = 0; i < element.getConcept().size(); i++) 2775 composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i); 2776 } 2777 2778 protected void composeCodeSystemCodeSystemContactComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemContactComponent element, int index) { 2779 if (element == null) 2780 return; 2781 Complex t; 2782 if (Utilities.noString(parentType)) 2783 t = parent; 2784 else { 2785 t = parent.predicate("fhir:"+parentType+'.'+name); 2786 } 2787 composeBackboneElement(t, "contact", name, element, index); 2788 if (element.hasNameElement()) 2789 composeString(t, "CodeSystem", "name", element.getNameElement(), -1); 2790 for (int i = 0; i < element.getTelecom().size(); i++) 2791 composeContactPoint(t, "CodeSystem", "telecom", element.getTelecom().get(i), i); 2792 } 2793 2794 protected void composeCodeSystemCodeSystemFilterComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemFilterComponent element, int index) { 2795 if (element == null) 2796 return; 2797 Complex t; 2798 if (Utilities.noString(parentType)) 2799 t = parent; 2800 else { 2801 t = parent.predicate("fhir:"+parentType+'.'+name); 2802 } 2803 composeBackboneElement(t, "filter", name, element, index); 2804 if (element.hasCodeElement()) 2805 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 2806 if (element.hasDescriptionElement()) 2807 composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 2808 for (int i = 0; i < element.getOperator().size(); i++) 2809 composeCode(t, "CodeSystem", "operator", element.getOperator().get(i), i); 2810 if (element.hasValueElement()) 2811 composeString(t, "CodeSystem", "value", element.getValueElement(), -1); 2812 } 2813 2814 protected void composeCodeSystemCodeSystemPropertyComponent(Complex parent, String parentType, String name, CodeSystem.CodeSystemPropertyComponent element, int index) { 2815 if (element == null) 2816 return; 2817 Complex t; 2818 if (Utilities.noString(parentType)) 2819 t = parent; 2820 else { 2821 t = parent.predicate("fhir:"+parentType+'.'+name); 2822 } 2823 composeBackboneElement(t, "property", name, element, index); 2824 if (element.hasCodeElement()) 2825 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 2826 if (element.hasDescriptionElement()) 2827 composeString(t, "CodeSystem", "description", element.getDescriptionElement(), -1); 2828 if (element.hasTypeElement()) 2829 composeEnum(t, "CodeSystem", "type", element.getTypeElement(), -1); 2830 } 2831 2832 protected void composeCodeSystemConceptDefinitionComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionComponent element, int index) { 2833 if (element == null) 2834 return; 2835 Complex t; 2836 if (Utilities.noString(parentType)) 2837 t = parent; 2838 else { 2839 t = parent.predicate("fhir:"+parentType+'.'+name); 2840 } 2841 composeBackboneElement(t, "concept", name, element, index); 2842 if (element.hasCodeElement()) 2843 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 2844 if (element.hasDisplayElement()) 2845 composeString(t, "CodeSystem", "display", element.getDisplayElement(), -1); 2846 if (element.hasDefinitionElement()) 2847 composeString(t, "CodeSystem", "definition", element.getDefinitionElement(), -1); 2848 for (int i = 0; i < element.getDesignation().size(); i++) 2849 composeCodeSystemConceptDefinitionDesignationComponent(t, "CodeSystem", "designation", element.getDesignation().get(i), i); 2850 for (int i = 0; i < element.getProperty().size(); i++) 2851 composeCodeSystemConceptDefinitionPropertyComponent(t, "CodeSystem", "property", element.getProperty().get(i), i); 2852 for (int i = 0; i < element.getConcept().size(); i++) 2853 composeCodeSystemConceptDefinitionComponent(t, "CodeSystem", "concept", element.getConcept().get(i), i); 2854 } 2855 2856 protected void composeCodeSystemConceptDefinitionDesignationComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionDesignationComponent element, int index) { 2857 if (element == null) 2858 return; 2859 Complex t; 2860 if (Utilities.noString(parentType)) 2861 t = parent; 2862 else { 2863 t = parent.predicate("fhir:"+parentType+'.'+name); 2864 } 2865 composeBackboneElement(t, "designation", name, element, index); 2866 if (element.hasLanguageElement()) 2867 composeCode(t, "CodeSystem", "language", element.getLanguageElement(), -1); 2868 if (element.hasUse()) 2869 composeCoding(t, "CodeSystem", "use", element.getUse(), -1); 2870 if (element.hasValueElement()) 2871 composeString(t, "CodeSystem", "value", element.getValueElement(), -1); 2872 } 2873 2874 protected void composeCodeSystemConceptDefinitionPropertyComponent(Complex parent, String parentType, String name, CodeSystem.ConceptDefinitionPropertyComponent element, int index) { 2875 if (element == null) 2876 return; 2877 Complex t; 2878 if (Utilities.noString(parentType)) 2879 t = parent; 2880 else { 2881 t = parent.predicate("fhir:"+parentType+'.'+name); 2882 } 2883 composeBackboneElement(t, "property", name, element, index); 2884 if (element.hasCodeElement()) 2885 composeCode(t, "CodeSystem", "code", element.getCodeElement(), -1); 2886 if (element.hasValue()) 2887 composeType(t, "CodeSystem", "value", element.getValue(), -1); 2888 } 2889 2890 protected void composeCommunication(Complex parent, String parentType, String name, Communication element, int index) { 2891 if (element == null) 2892 return; 2893 Complex t; 2894 if (Utilities.noString(parentType)) 2895 t = parent; 2896 else { 2897 t = parent.predicate("fhir:"+parentType+'.'+name); 2898 } 2899 composeDomainResource(t, "Communication", name, element, index); 2900 for (int i = 0; i < element.getIdentifier().size(); i++) 2901 composeIdentifier(t, "Communication", "identifier", element.getIdentifier().get(i), i); 2902 if (element.hasCategory()) 2903 composeCodeableConcept(t, "Communication", "category", element.getCategory(), -1); 2904 if (element.hasSender()) 2905 composeReference(t, "Communication", "sender", element.getSender(), -1); 2906 for (int i = 0; i < element.getRecipient().size(); i++) 2907 composeReference(t, "Communication", "recipient", element.getRecipient().get(i), i); 2908 for (int i = 0; i < element.getPayload().size(); i++) 2909 composeCommunicationCommunicationPayloadComponent(t, "Communication", "payload", element.getPayload().get(i), i); 2910 for (int i = 0; i < element.getMedium().size(); i++) 2911 composeCodeableConcept(t, "Communication", "medium", element.getMedium().get(i), i); 2912 if (element.hasStatusElement()) 2913 composeEnum(t, "Communication", "status", element.getStatusElement(), -1); 2914 if (element.hasEncounter()) 2915 composeReference(t, "Communication", "encounter", element.getEncounter(), -1); 2916 if (element.hasSentElement()) 2917 composeDateTime(t, "Communication", "sent", element.getSentElement(), -1); 2918 if (element.hasReceivedElement()) 2919 composeDateTime(t, "Communication", "received", element.getReceivedElement(), -1); 2920 for (int i = 0; i < element.getReason().size(); i++) 2921 composeCodeableConcept(t, "Communication", "reason", element.getReason().get(i), i); 2922 if (element.hasSubject()) 2923 composeReference(t, "Communication", "subject", element.getSubject(), -1); 2924 if (element.hasRequestDetail()) 2925 composeReference(t, "Communication", "requestDetail", element.getRequestDetail(), -1); 2926 } 2927 2928 protected void composeCommunicationCommunicationPayloadComponent(Complex parent, String parentType, String name, Communication.CommunicationPayloadComponent element, int index) { 2929 if (element == null) 2930 return; 2931 Complex t; 2932 if (Utilities.noString(parentType)) 2933 t = parent; 2934 else { 2935 t = parent.predicate("fhir:"+parentType+'.'+name); 2936 } 2937 composeBackboneElement(t, "payload", name, element, index); 2938 if (element.hasContent()) 2939 composeType(t, "Communication", "content", element.getContent(), -1); 2940 } 2941 2942 protected void composeCommunicationRequest(Complex parent, String parentType, String name, CommunicationRequest element, int index) { 2943 if (element == null) 2944 return; 2945 Complex t; 2946 if (Utilities.noString(parentType)) 2947 t = parent; 2948 else { 2949 t = parent.predicate("fhir:"+parentType+'.'+name); 2950 } 2951 composeDomainResource(t, "CommunicationRequest", name, element, index); 2952 for (int i = 0; i < element.getIdentifier().size(); i++) 2953 composeIdentifier(t, "CommunicationRequest", "identifier", element.getIdentifier().get(i), i); 2954 if (element.hasCategory()) 2955 composeCodeableConcept(t, "CommunicationRequest", "category", element.getCategory(), -1); 2956 if (element.hasSender()) 2957 composeReference(t, "CommunicationRequest", "sender", element.getSender(), -1); 2958 for (int i = 0; i < element.getRecipient().size(); i++) 2959 composeReference(t, "CommunicationRequest", "recipient", element.getRecipient().get(i), i); 2960 for (int i = 0; i < element.getPayload().size(); i++) 2961 composeCommunicationRequestCommunicationRequestPayloadComponent(t, "CommunicationRequest", "payload", element.getPayload().get(i), i); 2962 for (int i = 0; i < element.getMedium().size(); i++) 2963 composeCodeableConcept(t, "CommunicationRequest", "medium", element.getMedium().get(i), i); 2964 if (element.hasRequester()) 2965 composeReference(t, "CommunicationRequest", "requester", element.getRequester(), -1); 2966 if (element.hasStatusElement()) 2967 composeEnum(t, "CommunicationRequest", "status", element.getStatusElement(), -1); 2968 if (element.hasEncounter()) 2969 composeReference(t, "CommunicationRequest", "encounter", element.getEncounter(), -1); 2970 if (element.hasScheduled()) 2971 composeType(t, "CommunicationRequest", "scheduled", element.getScheduled(), -1); 2972 for (int i = 0; i < element.getReason().size(); i++) 2973 composeCodeableConcept(t, "CommunicationRequest", "reason", element.getReason().get(i), i); 2974 if (element.hasRequestedOnElement()) 2975 composeDateTime(t, "CommunicationRequest", "requestedOn", element.getRequestedOnElement(), -1); 2976 if (element.hasSubject()) 2977 composeReference(t, "CommunicationRequest", "subject", element.getSubject(), -1); 2978 if (element.hasPriority()) 2979 composeCodeableConcept(t, "CommunicationRequest", "priority", element.getPriority(), -1); 2980 } 2981 2982 protected void composeCommunicationRequestCommunicationRequestPayloadComponent(Complex parent, String parentType, String name, CommunicationRequest.CommunicationRequestPayloadComponent element, int index) { 2983 if (element == null) 2984 return; 2985 Complex t; 2986 if (Utilities.noString(parentType)) 2987 t = parent; 2988 else { 2989 t = parent.predicate("fhir:"+parentType+'.'+name); 2990 } 2991 composeBackboneElement(t, "payload", name, element, index); 2992 if (element.hasContent()) 2993 composeType(t, "CommunicationRequest", "content", element.getContent(), -1); 2994 } 2995 2996 protected void composeCompartmentDefinition(Complex parent, String parentType, String name, CompartmentDefinition element, int index) { 2997 if (element == null) 2998 return; 2999 Complex t; 3000 if (Utilities.noString(parentType)) 3001 t = parent; 3002 else { 3003 t = parent.predicate("fhir:"+parentType+'.'+name); 3004 } 3005 composeDomainResource(t, "CompartmentDefinition", name, element, index); 3006 if (element.hasUrlElement()) 3007 composeUri(t, "CompartmentDefinition", "url", element.getUrlElement(), -1); 3008 if (element.hasNameElement()) 3009 composeString(t, "CompartmentDefinition", "name", element.getNameElement(), -1); 3010 if (element.hasStatusElement()) 3011 composeEnum(t, "CompartmentDefinition", "status", element.getStatusElement(), -1); 3012 if (element.hasExperimentalElement()) 3013 composeBoolean(t, "CompartmentDefinition", "experimental", element.getExperimentalElement(), -1); 3014 if (element.hasPublisherElement()) 3015 composeString(t, "CompartmentDefinition", "publisher", element.getPublisherElement(), -1); 3016 for (int i = 0; i < element.getContact().size(); i++) 3017 composeCompartmentDefinitionCompartmentDefinitionContactComponent(t, "CompartmentDefinition", "contact", element.getContact().get(i), i); 3018 if (element.hasDateElement()) 3019 composeDateTime(t, "CompartmentDefinition", "date", element.getDateElement(), -1); 3020 if (element.hasDescriptionElement()) 3021 composeString(t, "CompartmentDefinition", "description", element.getDescriptionElement(), -1); 3022 if (element.hasRequirementsElement()) 3023 composeString(t, "CompartmentDefinition", "requirements", element.getRequirementsElement(), -1); 3024 if (element.hasCodeElement()) 3025 composeEnum(t, "CompartmentDefinition", "code", element.getCodeElement(), -1); 3026 if (element.hasSearchElement()) 3027 composeBoolean(t, "CompartmentDefinition", "search", element.getSearchElement(), -1); 3028 for (int i = 0; i < element.getResource().size(); i++) 3029 composeCompartmentDefinitionCompartmentDefinitionResourceComponent(t, "CompartmentDefinition", "resource", element.getResource().get(i), i); 3030 } 3031 3032 protected void composeCompartmentDefinitionCompartmentDefinitionContactComponent(Complex parent, String parentType, String name, CompartmentDefinition.CompartmentDefinitionContactComponent element, int index) { 3033 if (element == null) 3034 return; 3035 Complex t; 3036 if (Utilities.noString(parentType)) 3037 t = parent; 3038 else { 3039 t = parent.predicate("fhir:"+parentType+'.'+name); 3040 } 3041 composeBackboneElement(t, "contact", name, element, index); 3042 if (element.hasNameElement()) 3043 composeString(t, "CompartmentDefinition", "name", element.getNameElement(), -1); 3044 for (int i = 0; i < element.getTelecom().size(); i++) 3045 composeContactPoint(t, "CompartmentDefinition", "telecom", element.getTelecom().get(i), i); 3046 } 3047 3048 protected void composeCompartmentDefinitionCompartmentDefinitionResourceComponent(Complex parent, String parentType, String name, CompartmentDefinition.CompartmentDefinitionResourceComponent element, int index) { 3049 if (element == null) 3050 return; 3051 Complex t; 3052 if (Utilities.noString(parentType)) 3053 t = parent; 3054 else { 3055 t = parent.predicate("fhir:"+parentType+'.'+name); 3056 } 3057 composeBackboneElement(t, "resource", name, element, index); 3058 if (element.hasCodeElement()) 3059 composeCode(t, "CompartmentDefinition", "code", element.getCodeElement(), -1); 3060 for (int i = 0; i < element.getParam().size(); i++) 3061 composeString(t, "CompartmentDefinition", "param", element.getParam().get(i), i); 3062 if (element.hasDocumentationElement()) 3063 composeString(t, "CompartmentDefinition", "documentation", element.getDocumentationElement(), -1); 3064 } 3065 3066 protected void composeComposition(Complex parent, String parentType, String name, Composition element, int index) { 3067 if (element == null) 3068 return; 3069 Complex t; 3070 if (Utilities.noString(parentType)) 3071 t = parent; 3072 else { 3073 t = parent.predicate("fhir:"+parentType+'.'+name); 3074 } 3075 composeDomainResource(t, "Composition", name, element, index); 3076 if (element.hasIdentifier()) 3077 composeIdentifier(t, "Composition", "identifier", element.getIdentifier(), -1); 3078 if (element.hasDateElement()) 3079 composeDateTime(t, "Composition", "date", element.getDateElement(), -1); 3080 if (element.hasType()) 3081 composeCodeableConcept(t, "Composition", "type", element.getType(), -1); 3082 if (element.hasClass_()) 3083 composeCodeableConcept(t, "Composition", "class", element.getClass_(), -1); 3084 if (element.hasTitleElement()) 3085 composeString(t, "Composition", "title", element.getTitleElement(), -1); 3086 if (element.hasStatusElement()) 3087 composeEnum(t, "Composition", "status", element.getStatusElement(), -1); 3088 if (element.hasConfidentialityElement()) 3089 composeCode(t, "Composition", "confidentiality", element.getConfidentialityElement(), -1); 3090 if (element.hasSubject()) 3091 composeReference(t, "Composition", "subject", element.getSubject(), -1); 3092 for (int i = 0; i < element.getAuthor().size(); i++) 3093 composeReference(t, "Composition", "author", element.getAuthor().get(i), i); 3094 for (int i = 0; i < element.getAttester().size(); i++) 3095 composeCompositionCompositionAttesterComponent(t, "Composition", "attester", element.getAttester().get(i), i); 3096 if (element.hasCustodian()) 3097 composeReference(t, "Composition", "custodian", element.getCustodian(), -1); 3098 for (int i = 0; i < element.getEvent().size(); i++) 3099 composeCompositionCompositionEventComponent(t, "Composition", "event", element.getEvent().get(i), i); 3100 if (element.hasEncounter()) 3101 composeReference(t, "Composition", "encounter", element.getEncounter(), -1); 3102 for (int i = 0; i < element.getSection().size(); i++) 3103 composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i); 3104 } 3105 3106 protected void composeCompositionCompositionAttesterComponent(Complex parent, String parentType, String name, Composition.CompositionAttesterComponent element, int index) { 3107 if (element == null) 3108 return; 3109 Complex t; 3110 if (Utilities.noString(parentType)) 3111 t = parent; 3112 else { 3113 t = parent.predicate("fhir:"+parentType+'.'+name); 3114 } 3115 composeBackboneElement(t, "attester", name, element, index); 3116 for (int i = 0; i < element.getMode().size(); i++) 3117 composeEnum(t, "Composition", "mode", element.getMode().get(i), i); 3118 if (element.hasTimeElement()) 3119 composeDateTime(t, "Composition", "time", element.getTimeElement(), -1); 3120 if (element.hasParty()) 3121 composeReference(t, "Composition", "party", element.getParty(), -1); 3122 } 3123 3124 protected void composeCompositionCompositionEventComponent(Complex parent, String parentType, String name, Composition.CompositionEventComponent element, int index) { 3125 if (element == null) 3126 return; 3127 Complex t; 3128 if (Utilities.noString(parentType)) 3129 t = parent; 3130 else { 3131 t = parent.predicate("fhir:"+parentType+'.'+name); 3132 } 3133 composeBackboneElement(t, "event", name, element, index); 3134 for (int i = 0; i < element.getCode().size(); i++) 3135 composeCodeableConcept(t, "Composition", "code", element.getCode().get(i), i); 3136 if (element.hasPeriod()) 3137 composePeriod(t, "Composition", "period", element.getPeriod(), -1); 3138 for (int i = 0; i < element.getDetail().size(); i++) 3139 composeReference(t, "Composition", "detail", element.getDetail().get(i), i); 3140 } 3141 3142 protected void composeCompositionSectionComponent(Complex parent, String parentType, String name, Composition.SectionComponent element, int index) { 3143 if (element == null) 3144 return; 3145 Complex t; 3146 if (Utilities.noString(parentType)) 3147 t = parent; 3148 else { 3149 t = parent.predicate("fhir:"+parentType+'.'+name); 3150 } 3151 composeBackboneElement(t, "section", name, element, index); 3152 if (element.hasTitleElement()) 3153 composeString(t, "Composition", "title", element.getTitleElement(), -1); 3154 if (element.hasCode()) 3155 composeCodeableConcept(t, "Composition", "code", element.getCode(), -1); 3156 if (element.hasText()) 3157 composeNarrative(t, "Composition", "text", element.getText(), -1); 3158 if (element.hasModeElement()) 3159 composeCode(t, "Composition", "mode", element.getModeElement(), -1); 3160 if (element.hasOrderedBy()) 3161 composeCodeableConcept(t, "Composition", "orderedBy", element.getOrderedBy(), -1); 3162 for (int i = 0; i < element.getEntry().size(); i++) 3163 composeReference(t, "Composition", "entry", element.getEntry().get(i), i); 3164 if (element.hasEmptyReason()) 3165 composeCodeableConcept(t, "Composition", "emptyReason", element.getEmptyReason(), -1); 3166 for (int i = 0; i < element.getSection().size(); i++) 3167 composeCompositionSectionComponent(t, "Composition", "section", element.getSection().get(i), i); 3168 } 3169 3170 protected void composeConceptMap(Complex parent, String parentType, String name, ConceptMap element, int index) { 3171 if (element == null) 3172 return; 3173 Complex t; 3174 if (Utilities.noString(parentType)) 3175 t = parent; 3176 else { 3177 t = parent.predicate("fhir:"+parentType+'.'+name); 3178 } 3179 composeDomainResource(t, "ConceptMap", name, element, index); 3180 if (element.hasUrlElement()) 3181 composeUri(t, "ConceptMap", "url", element.getUrlElement(), -1); 3182 if (element.hasIdentifier()) 3183 composeIdentifier(t, "ConceptMap", "identifier", element.getIdentifier(), -1); 3184 if (element.hasVersionElement()) 3185 composeString(t, "ConceptMap", "version", element.getVersionElement(), -1); 3186 if (element.hasNameElement()) 3187 composeString(t, "ConceptMap", "name", element.getNameElement(), -1); 3188 if (element.hasStatusElement()) 3189 composeEnum(t, "ConceptMap", "status", element.getStatusElement(), -1); 3190 if (element.hasExperimentalElement()) 3191 composeBoolean(t, "ConceptMap", "experimental", element.getExperimentalElement(), -1); 3192 if (element.hasPublisherElement()) 3193 composeString(t, "ConceptMap", "publisher", element.getPublisherElement(), -1); 3194 for (int i = 0; i < element.getContact().size(); i++) 3195 composeConceptMapConceptMapContactComponent(t, "ConceptMap", "contact", element.getContact().get(i), i); 3196 if (element.hasDateElement()) 3197 composeDateTime(t, "ConceptMap", "date", element.getDateElement(), -1); 3198 if (element.hasDescriptionElement()) 3199 composeString(t, "ConceptMap", "description", element.getDescriptionElement(), -1); 3200 for (int i = 0; i < element.getUseContext().size(); i++) 3201 composeCodeableConcept(t, "ConceptMap", "useContext", element.getUseContext().get(i), i); 3202 if (element.hasRequirementsElement()) 3203 composeString(t, "ConceptMap", "requirements", element.getRequirementsElement(), -1); 3204 if (element.hasCopyrightElement()) 3205 composeString(t, "ConceptMap", "copyright", element.getCopyrightElement(), -1); 3206 if (element.hasSource()) 3207 composeType(t, "ConceptMap", "source", element.getSource(), -1); 3208 if (element.hasTarget()) 3209 composeType(t, "ConceptMap", "target", element.getTarget(), -1); 3210 for (int i = 0; i < element.getElement().size(); i++) 3211 composeConceptMapSourceElementComponent(t, "ConceptMap", "element", element.getElement().get(i), i); 3212 } 3213 3214 protected void composeConceptMapConceptMapContactComponent(Complex parent, String parentType, String name, ConceptMap.ConceptMapContactComponent element, int index) { 3215 if (element == null) 3216 return; 3217 Complex t; 3218 if (Utilities.noString(parentType)) 3219 t = parent; 3220 else { 3221 t = parent.predicate("fhir:"+parentType+'.'+name); 3222 } 3223 composeBackboneElement(t, "contact", name, element, index); 3224 if (element.hasNameElement()) 3225 composeString(t, "ConceptMap", "name", element.getNameElement(), -1); 3226 for (int i = 0; i < element.getTelecom().size(); i++) 3227 composeContactPoint(t, "ConceptMap", "telecom", element.getTelecom().get(i), i); 3228 } 3229 3230 protected void composeConceptMapSourceElementComponent(Complex parent, String parentType, String name, ConceptMap.SourceElementComponent element, int index) { 3231 if (element == null) 3232 return; 3233 Complex t; 3234 if (Utilities.noString(parentType)) 3235 t = parent; 3236 else { 3237 t = parent.predicate("fhir:"+parentType+'.'+name); 3238 } 3239 composeBackboneElement(t, "element", name, element, index); 3240 if (element.hasSystemElement()) 3241 composeUri(t, "ConceptMap", "system", element.getSystemElement(), -1); 3242 if (element.hasVersionElement()) 3243 composeString(t, "ConceptMap", "version", element.getVersionElement(), -1); 3244 if (element.hasCodeElement()) 3245 composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1); 3246 for (int i = 0; i < element.getTarget().size(); i++) 3247 composeConceptMapTargetElementComponent(t, "ConceptMap", "target", element.getTarget().get(i), i); 3248 } 3249 3250 protected void composeConceptMapTargetElementComponent(Complex parent, String parentType, String name, ConceptMap.TargetElementComponent element, int index) { 3251 if (element == null) 3252 return; 3253 Complex t; 3254 if (Utilities.noString(parentType)) 3255 t = parent; 3256 else { 3257 t = parent.predicate("fhir:"+parentType+'.'+name); 3258 } 3259 composeBackboneElement(t, "target", name, element, index); 3260 if (element.hasSystemElement()) 3261 composeUri(t, "ConceptMap", "system", element.getSystemElement(), -1); 3262 if (element.hasVersionElement()) 3263 composeString(t, "ConceptMap", "version", element.getVersionElement(), -1); 3264 if (element.hasCodeElement()) 3265 composeCode(t, "ConceptMap", "code", element.getCodeElement(), -1); 3266 if (element.hasEquivalenceElement()) 3267 composeEnum(t, "ConceptMap", "equivalence", element.getEquivalenceElement(), -1); 3268 if (element.hasCommentsElement()) 3269 composeString(t, "ConceptMap", "comments", element.getCommentsElement(), -1); 3270 for (int i = 0; i < element.getDependsOn().size(); i++) 3271 composeConceptMapOtherElementComponent(t, "ConceptMap", "dependsOn", element.getDependsOn().get(i), i); 3272 for (int i = 0; i < element.getProduct().size(); i++) 3273 composeConceptMapOtherElementComponent(t, "ConceptMap", "product", element.getProduct().get(i), i); 3274 } 3275 3276 protected void composeConceptMapOtherElementComponent(Complex parent, String parentType, String name, ConceptMap.OtherElementComponent element, int index) { 3277 if (element == null) 3278 return; 3279 Complex t; 3280 if (Utilities.noString(parentType)) 3281 t = parent; 3282 else { 3283 t = parent.predicate("fhir:"+parentType+'.'+name); 3284 } 3285 composeBackboneElement(t, "dependsOn", name, element, index); 3286 if (element.hasElementElement()) 3287 composeUri(t, "ConceptMap", "element", element.getElementElement(), -1); 3288 if (element.hasSystemElement()) 3289 composeUri(t, "ConceptMap", "system", element.getSystemElement(), -1); 3290 if (element.hasCodeElement()) 3291 composeString(t, "ConceptMap", "code", element.getCodeElement(), -1); 3292 } 3293 3294 protected void composeCondition(Complex parent, String parentType, String name, Condition element, int index) { 3295 if (element == null) 3296 return; 3297 Complex t; 3298 if (Utilities.noString(parentType)) 3299 t = parent; 3300 else { 3301 t = parent.predicate("fhir:"+parentType+'.'+name); 3302 } 3303 composeDomainResource(t, "Condition", name, element, index); 3304 for (int i = 0; i < element.getIdentifier().size(); i++) 3305 composeIdentifier(t, "Condition", "identifier", element.getIdentifier().get(i), i); 3306 if (element.hasPatient()) 3307 composeReference(t, "Condition", "patient", element.getPatient(), -1); 3308 if (element.hasEncounter()) 3309 composeReference(t, "Condition", "encounter", element.getEncounter(), -1); 3310 if (element.hasAsserter()) 3311 composeReference(t, "Condition", "asserter", element.getAsserter(), -1); 3312 if (element.hasDateRecordedElement()) 3313 composeDate(t, "Condition", "dateRecorded", element.getDateRecordedElement(), -1); 3314 if (element.hasCode()) 3315 composeCodeableConcept(t, "Condition", "code", element.getCode(), -1); 3316 if (element.hasCategory()) 3317 composeCodeableConcept(t, "Condition", "category", element.getCategory(), -1); 3318 if (element.hasClinicalStatusElement()) 3319 composeCode(t, "Condition", "clinicalStatus", element.getClinicalStatusElement(), -1); 3320 if (element.hasVerificationStatusElement()) 3321 composeEnum(t, "Condition", "verificationStatus", element.getVerificationStatusElement(), -1); 3322 if (element.hasSeverity()) 3323 composeCodeableConcept(t, "Condition", "severity", element.getSeverity(), -1); 3324 if (element.hasOnset()) 3325 composeType(t, "Condition", "onset", element.getOnset(), -1); 3326 if (element.hasAbatement()) 3327 composeType(t, "Condition", "abatement", element.getAbatement(), -1); 3328 if (element.hasStage()) 3329 composeConditionConditionStageComponent(t, "Condition", "stage", element.getStage(), -1); 3330 for (int i = 0; i < element.getEvidence().size(); i++) 3331 composeConditionConditionEvidenceComponent(t, "Condition", "evidence", element.getEvidence().get(i), i); 3332 for (int i = 0; i < element.getBodySite().size(); i++) 3333 composeCodeableConcept(t, "Condition", "bodySite", element.getBodySite().get(i), i); 3334 if (element.hasNotesElement()) 3335 composeString(t, "Condition", "notes", element.getNotesElement(), -1); 3336 } 3337 3338 protected void composeConditionConditionStageComponent(Complex parent, String parentType, String name, Condition.ConditionStageComponent element, int index) { 3339 if (element == null) 3340 return; 3341 Complex t; 3342 if (Utilities.noString(parentType)) 3343 t = parent; 3344 else { 3345 t = parent.predicate("fhir:"+parentType+'.'+name); 3346 } 3347 composeBackboneElement(t, "stage", name, element, index); 3348 if (element.hasSummary()) 3349 composeCodeableConcept(t, "Condition", "summary", element.getSummary(), -1); 3350 for (int i = 0; i < element.getAssessment().size(); i++) 3351 composeReference(t, "Condition", "assessment", element.getAssessment().get(i), i); 3352 } 3353 3354 protected void composeConditionConditionEvidenceComponent(Complex parent, String parentType, String name, Condition.ConditionEvidenceComponent element, int index) { 3355 if (element == null) 3356 return; 3357 Complex t; 3358 if (Utilities.noString(parentType)) 3359 t = parent; 3360 else { 3361 t = parent.predicate("fhir:"+parentType+'.'+name); 3362 } 3363 composeBackboneElement(t, "evidence", name, element, index); 3364 if (element.hasCode()) 3365 composeCodeableConcept(t, "Condition", "code", element.getCode(), -1); 3366 for (int i = 0; i < element.getDetail().size(); i++) 3367 composeReference(t, "Condition", "detail", element.getDetail().get(i), i); 3368 } 3369 3370 protected void composeConformance(Complex parent, String parentType, String name, Conformance element, int index) { 3371 if (element == null) 3372 return; 3373 Complex t; 3374 if (Utilities.noString(parentType)) 3375 t = parent; 3376 else { 3377 t = parent.predicate("fhir:"+parentType+'.'+name); 3378 } 3379 composeDomainResource(t, "Conformance", name, element, index); 3380 if (element.hasUrlElement()) 3381 composeUri(t, "Conformance", "url", element.getUrlElement(), -1); 3382 if (element.hasVersionElement()) 3383 composeString(t, "Conformance", "version", element.getVersionElement(), -1); 3384 if (element.hasNameElement()) 3385 composeString(t, "Conformance", "name", element.getNameElement(), -1); 3386 if (element.hasStatusElement()) 3387 composeEnum(t, "Conformance", "status", element.getStatusElement(), -1); 3388 if (element.hasExperimentalElement()) 3389 composeBoolean(t, "Conformance", "experimental", element.getExperimentalElement(), -1); 3390 if (element.hasDateElement()) 3391 composeDateTime(t, "Conformance", "date", element.getDateElement(), -1); 3392 if (element.hasPublisherElement()) 3393 composeString(t, "Conformance", "publisher", element.getPublisherElement(), -1); 3394 for (int i = 0; i < element.getContact().size(); i++) 3395 composeConformanceConformanceContactComponent(t, "Conformance", "contact", element.getContact().get(i), i); 3396 if (element.hasDescriptionElement()) 3397 composeString(t, "Conformance", "description", element.getDescriptionElement(), -1); 3398 for (int i = 0; i < element.getUseContext().size(); i++) 3399 composeCodeableConcept(t, "Conformance", "useContext", element.getUseContext().get(i), i); 3400 if (element.hasRequirementsElement()) 3401 composeString(t, "Conformance", "requirements", element.getRequirementsElement(), -1); 3402 if (element.hasCopyrightElement()) 3403 composeString(t, "Conformance", "copyright", element.getCopyrightElement(), -1); 3404 if (element.hasKindElement()) 3405 composeEnum(t, "Conformance", "kind", element.getKindElement(), -1); 3406 if (element.hasSoftware()) 3407 composeConformanceConformanceSoftwareComponent(t, "Conformance", "software", element.getSoftware(), -1); 3408 if (element.hasImplementation()) 3409 composeConformanceConformanceImplementationComponent(t, "Conformance", "implementation", element.getImplementation(), -1); 3410 if (element.hasFhirVersionElement()) 3411 composeId(t, "Conformance", "fhirVersion", element.getFhirVersionElement(), -1); 3412 if (element.hasAcceptUnknownElement()) 3413 composeEnum(t, "Conformance", "acceptUnknown", element.getAcceptUnknownElement(), -1); 3414 for (int i = 0; i < element.getFormat().size(); i++) 3415 composeCode(t, "Conformance", "format", element.getFormat().get(i), i); 3416 for (int i = 0; i < element.getProfile().size(); i++) 3417 composeReference(t, "Conformance", "profile", element.getProfile().get(i), i); 3418 for (int i = 0; i < element.getRest().size(); i++) 3419 composeConformanceConformanceRestComponent(t, "Conformance", "rest", element.getRest().get(i), i); 3420 for (int i = 0; i < element.getMessaging().size(); i++) 3421 composeConformanceConformanceMessagingComponent(t, "Conformance", "messaging", element.getMessaging().get(i), i); 3422 for (int i = 0; i < element.getDocument().size(); i++) 3423 composeConformanceConformanceDocumentComponent(t, "Conformance", "document", element.getDocument().get(i), i); 3424 } 3425 3426 protected void composeConformanceConformanceContactComponent(Complex parent, String parentType, String name, Conformance.ConformanceContactComponent element, int index) { 3427 if (element == null) 3428 return; 3429 Complex t; 3430 if (Utilities.noString(parentType)) 3431 t = parent; 3432 else { 3433 t = parent.predicate("fhir:"+parentType+'.'+name); 3434 } 3435 composeBackboneElement(t, "contact", name, element, index); 3436 if (element.hasNameElement()) 3437 composeString(t, "Conformance", "name", element.getNameElement(), -1); 3438 for (int i = 0; i < element.getTelecom().size(); i++) 3439 composeContactPoint(t, "Conformance", "telecom", element.getTelecom().get(i), i); 3440 } 3441 3442 protected void composeConformanceConformanceSoftwareComponent(Complex parent, String parentType, String name, Conformance.ConformanceSoftwareComponent element, int index) { 3443 if (element == null) 3444 return; 3445 Complex t; 3446 if (Utilities.noString(parentType)) 3447 t = parent; 3448 else { 3449 t = parent.predicate("fhir:"+parentType+'.'+name); 3450 } 3451 composeBackboneElement(t, "software", name, element, index); 3452 if (element.hasNameElement()) 3453 composeString(t, "Conformance", "name", element.getNameElement(), -1); 3454 if (element.hasVersionElement()) 3455 composeString(t, "Conformance", "version", element.getVersionElement(), -1); 3456 if (element.hasReleaseDateElement()) 3457 composeDateTime(t, "Conformance", "releaseDate", element.getReleaseDateElement(), -1); 3458 } 3459 3460 protected void composeConformanceConformanceImplementationComponent(Complex parent, String parentType, String name, Conformance.ConformanceImplementationComponent element, int index) { 3461 if (element == null) 3462 return; 3463 Complex t; 3464 if (Utilities.noString(parentType)) 3465 t = parent; 3466 else { 3467 t = parent.predicate("fhir:"+parentType+'.'+name); 3468 } 3469 composeBackboneElement(t, "implementation", name, element, index); 3470 if (element.hasDescriptionElement()) 3471 composeString(t, "Conformance", "description", element.getDescriptionElement(), -1); 3472 if (element.hasUrlElement()) 3473 composeUri(t, "Conformance", "url", element.getUrlElement(), -1); 3474 } 3475 3476 protected void composeConformanceConformanceRestComponent(Complex parent, String parentType, String name, Conformance.ConformanceRestComponent element, int index) { 3477 if (element == null) 3478 return; 3479 Complex t; 3480 if (Utilities.noString(parentType)) 3481 t = parent; 3482 else { 3483 t = parent.predicate("fhir:"+parentType+'.'+name); 3484 } 3485 composeBackboneElement(t, "rest", name, element, index); 3486 if (element.hasModeElement()) 3487 composeEnum(t, "Conformance", "mode", element.getModeElement(), -1); 3488 if (element.hasDocumentationElement()) 3489 composeString(t, "Conformance", "documentation", element.getDocumentationElement(), -1); 3490 if (element.hasSecurity()) 3491 composeConformanceConformanceRestSecurityComponent(t, "Conformance", "security", element.getSecurity(), -1); 3492 for (int i = 0; i < element.getResource().size(); i++) 3493 composeConformanceConformanceRestResourceComponent(t, "Conformance", "resource", element.getResource().get(i), i); 3494 for (int i = 0; i < element.getInteraction().size(); i++) 3495 composeConformanceSystemInteractionComponent(t, "Conformance", "interaction", element.getInteraction().get(i), i); 3496 if (element.hasTransactionModeElement()) 3497 composeEnum(t, "Conformance", "transactionMode", element.getTransactionModeElement(), -1); 3498 for (int i = 0; i < element.getSearchParam().size(); i++) 3499 composeConformanceConformanceRestResourceSearchParamComponent(t, "Conformance", "searchParam", element.getSearchParam().get(i), i); 3500 for (int i = 0; i < element.getOperation().size(); i++) 3501 composeConformanceConformanceRestOperationComponent(t, "Conformance", "operation", element.getOperation().get(i), i); 3502 for (int i = 0; i < element.getCompartment().size(); i++) 3503 composeUri(t, "Conformance", "compartment", element.getCompartment().get(i), i); 3504 } 3505 3506 protected void composeConformanceConformanceRestSecurityComponent(Complex parent, String parentType, String name, Conformance.ConformanceRestSecurityComponent element, int index) { 3507 if (element == null) 3508 return; 3509 Complex t; 3510 if (Utilities.noString(parentType)) 3511 t = parent; 3512 else { 3513 t = parent.predicate("fhir:"+parentType+'.'+name); 3514 } 3515 composeBackboneElement(t, "security", name, element, index); 3516 if (element.hasCorsElement()) 3517 composeBoolean(t, "Conformance", "cors", element.getCorsElement(), -1); 3518 for (int i = 0; i < element.getService().size(); i++) 3519 composeCodeableConcept(t, "Conformance", "service", element.getService().get(i), i); 3520 if (element.hasDescriptionElement()) 3521 composeString(t, "Conformance", "description", element.getDescriptionElement(), -1); 3522 for (int i = 0; i < element.getCertificate().size(); i++) 3523 composeConformanceConformanceRestSecurityCertificateComponent(t, "Conformance", "certificate", element.getCertificate().get(i), i); 3524 } 3525 3526 protected void composeConformanceConformanceRestSecurityCertificateComponent(Complex parent, String parentType, String name, Conformance.ConformanceRestSecurityCertificateComponent element, int index) { 3527 if (element == null) 3528 return; 3529 Complex t; 3530 if (Utilities.noString(parentType)) 3531 t = parent; 3532 else { 3533 t = parent.predicate("fhir:"+parentType+'.'+name); 3534 } 3535 composeBackboneElement(t, "certificate", name, element, index); 3536 if (element.hasTypeElement()) 3537 composeCode(t, "Conformance", "type", element.getTypeElement(), -1); 3538 if (element.hasBlobElement()) 3539 composeBase64Binary(t, "Conformance", "blob", element.getBlobElement(), -1); 3540 } 3541 3542 protected void composeConformanceConformanceRestResourceComponent(Complex parent, String parentType, String name, Conformance.ConformanceRestResourceComponent element, int index) { 3543 if (element == null) 3544 return; 3545 Complex t; 3546 if (Utilities.noString(parentType)) 3547 t = parent; 3548 else { 3549 t = parent.predicate("fhir:"+parentType+'.'+name); 3550 } 3551 composeBackboneElement(t, "resource", name, element, index); 3552 if (element.hasTypeElement()) 3553 composeCode(t, "Conformance", "type", element.getTypeElement(), -1); 3554 if (element.hasProfile()) 3555 composeReference(t, "Conformance", "profile", element.getProfile(), -1); 3556 for (int i = 0; i < element.getInteraction().size(); i++) 3557 composeConformanceResourceInteractionComponent(t, "Conformance", "interaction", element.getInteraction().get(i), i); 3558 if (element.hasVersioningElement()) 3559 composeEnum(t, "Conformance", "versioning", element.getVersioningElement(), -1); 3560 if (element.hasReadHistoryElement()) 3561 composeBoolean(t, "Conformance", "readHistory", element.getReadHistoryElement(), -1); 3562 if (element.hasUpdateCreateElement()) 3563 composeBoolean(t, "Conformance", "updateCreate", element.getUpdateCreateElement(), -1); 3564 if (element.hasConditionalCreateElement()) 3565 composeBoolean(t, "Conformance", "conditionalCreate", element.getConditionalCreateElement(), -1); 3566 if (element.hasConditionalUpdateElement()) 3567 composeBoolean(t, "Conformance", "conditionalUpdate", element.getConditionalUpdateElement(), -1); 3568 if (element.hasConditionalDeleteElement()) 3569 composeEnum(t, "Conformance", "conditionalDelete", element.getConditionalDeleteElement(), -1); 3570 for (int i = 0; i < element.getSearchInclude().size(); i++) 3571 composeString(t, "Conformance", "searchInclude", element.getSearchInclude().get(i), i); 3572 for (int i = 0; i < element.getSearchRevInclude().size(); i++) 3573 composeString(t, "Conformance", "searchRevInclude", element.getSearchRevInclude().get(i), i); 3574 for (int i = 0; i < element.getSearchParam().size(); i++) 3575 composeConformanceConformanceRestResourceSearchParamComponent(t, "Conformance", "searchParam", element.getSearchParam().get(i), i); 3576 } 3577 3578 protected void composeConformanceResourceInteractionComponent(Complex parent, String parentType, String name, Conformance.ResourceInteractionComponent element, int index) { 3579 if (element == null) 3580 return; 3581 Complex t; 3582 if (Utilities.noString(parentType)) 3583 t = parent; 3584 else { 3585 t = parent.predicate("fhir:"+parentType+'.'+name); 3586 } 3587 composeBackboneElement(t, "interaction", name, element, index); 3588 if (element.hasCodeElement()) 3589 composeEnum(t, "Conformance", "code", element.getCodeElement(), -1); 3590 if (element.hasDocumentationElement()) 3591 composeString(t, "Conformance", "documentation", element.getDocumentationElement(), -1); 3592 } 3593 3594 protected void composeConformanceConformanceRestResourceSearchParamComponent(Complex parent, String parentType, String name, Conformance.ConformanceRestResourceSearchParamComponent element, int index) { 3595 if (element == null) 3596 return; 3597 Complex t; 3598 if (Utilities.noString(parentType)) 3599 t = parent; 3600 else { 3601 t = parent.predicate("fhir:"+parentType+'.'+name); 3602 } 3603 composeBackboneElement(t, "searchParam", name, element, index); 3604 if (element.hasNameElement()) 3605 composeString(t, "Conformance", "name", element.getNameElement(), -1); 3606 if (element.hasDefinitionElement()) 3607 composeUri(t, "Conformance", "definition", element.getDefinitionElement(), -1); 3608 if (element.hasTypeElement()) 3609 composeEnum(t, "Conformance", "type", element.getTypeElement(), -1); 3610 if (element.hasDocumentationElement()) 3611 composeString(t, "Conformance", "documentation", element.getDocumentationElement(), -1); 3612 for (int i = 0; i < element.getTarget().size(); i++) 3613 composeCode(t, "Conformance", "target", element.getTarget().get(i), i); 3614 for (int i = 0; i < element.getModifier().size(); i++) 3615 composeEnum(t, "Conformance", "modifier", element.getModifier().get(i), i); 3616 for (int i = 0; i < element.getChain().size(); i++) 3617 composeString(t, "Conformance", "chain", element.getChain().get(i), i); 3618 } 3619 3620 protected void composeConformanceSystemInteractionComponent(Complex parent, String parentType, String name, Conformance.SystemInteractionComponent element, int index) { 3621 if (element == null) 3622 return; 3623 Complex t; 3624 if (Utilities.noString(parentType)) 3625 t = parent; 3626 else { 3627 t = parent.predicate("fhir:"+parentType+'.'+name); 3628 } 3629 composeBackboneElement(t, "interaction", name, element, index); 3630 if (element.hasCodeElement()) 3631 composeEnum(t, "Conformance", "code", element.getCodeElement(), -1); 3632 if (element.hasDocumentationElement()) 3633 composeString(t, "Conformance", "documentation", element.getDocumentationElement(), -1); 3634 } 3635 3636 protected void composeConformanceConformanceRestOperationComponent(Complex parent, String parentType, String name, Conformance.ConformanceRestOperationComponent element, int index) { 3637 if (element == null) 3638 return; 3639 Complex t; 3640 if (Utilities.noString(parentType)) 3641 t = parent; 3642 else { 3643 t = parent.predicate("fhir:"+parentType+'.'+name); 3644 } 3645 composeBackboneElement(t, "operation", name, element, index); 3646 if (element.hasNameElement()) 3647 composeString(t, "Conformance", "name", element.getNameElement(), -1); 3648 if (element.hasDefinition()) 3649 composeReference(t, "Conformance", "definition", element.getDefinition(), -1); 3650 } 3651 3652 protected void composeConformanceConformanceMessagingComponent(Complex parent, String parentType, String name, Conformance.ConformanceMessagingComponent element, int index) { 3653 if (element == null) 3654 return; 3655 Complex t; 3656 if (Utilities.noString(parentType)) 3657 t = parent; 3658 else { 3659 t = parent.predicate("fhir:"+parentType+'.'+name); 3660 } 3661 composeBackboneElement(t, "messaging", name, element, index); 3662 for (int i = 0; i < element.getEndpoint().size(); i++) 3663 composeConformanceConformanceMessagingEndpointComponent(t, "Conformance", "endpoint", element.getEndpoint().get(i), i); 3664 if (element.hasReliableCacheElement()) 3665 composeUnsignedInt(t, "Conformance", "reliableCache", element.getReliableCacheElement(), -1); 3666 if (element.hasDocumentationElement()) 3667 composeString(t, "Conformance", "documentation", element.getDocumentationElement(), -1); 3668 for (int i = 0; i < element.getEvent().size(); i++) 3669 composeConformanceConformanceMessagingEventComponent(t, "Conformance", "event", element.getEvent().get(i), i); 3670 } 3671 3672 protected void composeConformanceConformanceMessagingEndpointComponent(Complex parent, String parentType, String name, Conformance.ConformanceMessagingEndpointComponent element, int index) { 3673 if (element == null) 3674 return; 3675 Complex t; 3676 if (Utilities.noString(parentType)) 3677 t = parent; 3678 else { 3679 t = parent.predicate("fhir:"+parentType+'.'+name); 3680 } 3681 composeBackboneElement(t, "endpoint", name, element, index); 3682 if (element.hasProtocol()) 3683 composeCoding(t, "Conformance", "protocol", element.getProtocol(), -1); 3684 if (element.hasAddressElement()) 3685 composeUri(t, "Conformance", "address", element.getAddressElement(), -1); 3686 } 3687 3688 protected void composeConformanceConformanceMessagingEventComponent(Complex parent, String parentType, String name, Conformance.ConformanceMessagingEventComponent element, int index) { 3689 if (element == null) 3690 return; 3691 Complex t; 3692 if (Utilities.noString(parentType)) 3693 t = parent; 3694 else { 3695 t = parent.predicate("fhir:"+parentType+'.'+name); 3696 } 3697 composeBackboneElement(t, "event", name, element, index); 3698 if (element.hasCode()) 3699 composeCoding(t, "Conformance", "code", element.getCode(), -1); 3700 if (element.hasCategoryElement()) 3701 composeEnum(t, "Conformance", "category", element.getCategoryElement(), -1); 3702 if (element.hasModeElement()) 3703 composeEnum(t, "Conformance", "mode", element.getModeElement(), -1); 3704 if (element.hasFocusElement()) 3705 composeCode(t, "Conformance", "focus", element.getFocusElement(), -1); 3706 if (element.hasRequest()) 3707 composeReference(t, "Conformance", "request", element.getRequest(), -1); 3708 if (element.hasResponse()) 3709 composeReference(t, "Conformance", "response", element.getResponse(), -1); 3710 if (element.hasDocumentationElement()) 3711 composeString(t, "Conformance", "documentation", element.getDocumentationElement(), -1); 3712 } 3713 3714 protected void composeConformanceConformanceDocumentComponent(Complex parent, String parentType, String name, Conformance.ConformanceDocumentComponent element, int index) { 3715 if (element == null) 3716 return; 3717 Complex t; 3718 if (Utilities.noString(parentType)) 3719 t = parent; 3720 else { 3721 t = parent.predicate("fhir:"+parentType+'.'+name); 3722 } 3723 composeBackboneElement(t, "document", name, element, index); 3724 if (element.hasModeElement()) 3725 composeEnum(t, "Conformance", "mode", element.getModeElement(), -1); 3726 if (element.hasDocumentationElement()) 3727 composeString(t, "Conformance", "documentation", element.getDocumentationElement(), -1); 3728 if (element.hasProfile()) 3729 composeReference(t, "Conformance", "profile", element.getProfile(), -1); 3730 } 3731 3732 protected void composeContract(Complex parent, String parentType, String name, Contract element, int index) { 3733 if (element == null) 3734 return; 3735 Complex t; 3736 if (Utilities.noString(parentType)) 3737 t = parent; 3738 else { 3739 t = parent.predicate("fhir:"+parentType+'.'+name); 3740 } 3741 composeDomainResource(t, "Contract", name, element, index); 3742 if (element.hasIdentifier()) 3743 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 3744 if (element.hasIssuedElement()) 3745 composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1); 3746 if (element.hasApplies()) 3747 composePeriod(t, "Contract", "applies", element.getApplies(), -1); 3748 for (int i = 0; i < element.getSubject().size(); i++) 3749 composeReference(t, "Contract", "subject", element.getSubject().get(i), i); 3750 for (int i = 0; i < element.getTopic().size(); i++) 3751 composeReference(t, "Contract", "topic", element.getTopic().get(i), i); 3752 for (int i = 0; i < element.getAuthority().size(); i++) 3753 composeReference(t, "Contract", "authority", element.getAuthority().get(i), i); 3754 for (int i = 0; i < element.getDomain().size(); i++) 3755 composeReference(t, "Contract", "domain", element.getDomain().get(i), i); 3756 if (element.hasType()) 3757 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 3758 for (int i = 0; i < element.getSubType().size(); i++) 3759 composeCodeableConcept(t, "Contract", "subType", element.getSubType().get(i), i); 3760 for (int i = 0; i < element.getAction().size(); i++) 3761 composeCodeableConcept(t, "Contract", "action", element.getAction().get(i), i); 3762 for (int i = 0; i < element.getActionReason().size(); i++) 3763 composeCodeableConcept(t, "Contract", "actionReason", element.getActionReason().get(i), i); 3764 for (int i = 0; i < element.getAgent().size(); i++) 3765 composeContractAgentComponent(t, "Contract", "agent", element.getAgent().get(i), i); 3766 for (int i = 0; i < element.getSigner().size(); i++) 3767 composeContractSignatoryComponent(t, "Contract", "signer", element.getSigner().get(i), i); 3768 for (int i = 0; i < element.getValuedItem().size(); i++) 3769 composeContractValuedItemComponent(t, "Contract", "valuedItem", element.getValuedItem().get(i), i); 3770 for (int i = 0; i < element.getTerm().size(); i++) 3771 composeContractTermComponent(t, "Contract", "term", element.getTerm().get(i), i); 3772 if (element.hasBinding()) 3773 composeType(t, "Contract", "binding", element.getBinding(), -1); 3774 for (int i = 0; i < element.getFriendly().size(); i++) 3775 composeContractFriendlyLanguageComponent(t, "Contract", "friendly", element.getFriendly().get(i), i); 3776 for (int i = 0; i < element.getLegal().size(); i++) 3777 composeContractLegalLanguageComponent(t, "Contract", "legal", element.getLegal().get(i), i); 3778 for (int i = 0; i < element.getRule().size(); i++) 3779 composeContractComputableLanguageComponent(t, "Contract", "rule", element.getRule().get(i), i); 3780 } 3781 3782 protected void composeContractAgentComponent(Complex parent, String parentType, String name, Contract.AgentComponent element, int index) { 3783 if (element == null) 3784 return; 3785 Complex t; 3786 if (Utilities.noString(parentType)) 3787 t = parent; 3788 else { 3789 t = parent.predicate("fhir:"+parentType+'.'+name); 3790 } 3791 composeBackboneElement(t, "agent", name, element, index); 3792 if (element.hasActor()) 3793 composeReference(t, "Contract", "actor", element.getActor(), -1); 3794 for (int i = 0; i < element.getRole().size(); i++) 3795 composeCodeableConcept(t, "Contract", "role", element.getRole().get(i), i); 3796 } 3797 3798 protected void composeContractSignatoryComponent(Complex parent, String parentType, String name, Contract.SignatoryComponent element, int index) { 3799 if (element == null) 3800 return; 3801 Complex t; 3802 if (Utilities.noString(parentType)) 3803 t = parent; 3804 else { 3805 t = parent.predicate("fhir:"+parentType+'.'+name); 3806 } 3807 composeBackboneElement(t, "signer", name, element, index); 3808 if (element.hasType()) 3809 composeCoding(t, "Contract", "type", element.getType(), -1); 3810 if (element.hasParty()) 3811 composeReference(t, "Contract", "party", element.getParty(), -1); 3812 for (int i = 0; i < element.getSignature().size(); i++) 3813 composeSignature(t, "Contract", "signature", element.getSignature().get(i), i); 3814 } 3815 3816 protected void composeContractValuedItemComponent(Complex parent, String parentType, String name, Contract.ValuedItemComponent element, int index) { 3817 if (element == null) 3818 return; 3819 Complex t; 3820 if (Utilities.noString(parentType)) 3821 t = parent; 3822 else { 3823 t = parent.predicate("fhir:"+parentType+'.'+name); 3824 } 3825 composeBackboneElement(t, "valuedItem", name, element, index); 3826 if (element.hasEntity()) 3827 composeType(t, "Contract", "entity", element.getEntity(), -1); 3828 if (element.hasIdentifier()) 3829 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 3830 if (element.hasEffectiveTimeElement()) 3831 composeDateTime(t, "Contract", "effectiveTime", element.getEffectiveTimeElement(), -1); 3832 if (element.hasQuantity()) 3833 composeQuantity(t, "Contract", "quantity", element.getQuantity(), -1); 3834 if (element.hasUnitPrice()) 3835 composeQuantity(t, "Contract", "unitPrice", element.getUnitPrice(), -1); 3836 if (element.hasFactorElement()) 3837 composeDecimal(t, "Contract", "factor", element.getFactorElement(), -1); 3838 if (element.hasPointsElement()) 3839 composeDecimal(t, "Contract", "points", element.getPointsElement(), -1); 3840 if (element.hasNet()) 3841 composeQuantity(t, "Contract", "net", element.getNet(), -1); 3842 } 3843 3844 protected void composeContractTermComponent(Complex parent, String parentType, String name, Contract.TermComponent element, int index) { 3845 if (element == null) 3846 return; 3847 Complex t; 3848 if (Utilities.noString(parentType)) 3849 t = parent; 3850 else { 3851 t = parent.predicate("fhir:"+parentType+'.'+name); 3852 } 3853 composeBackboneElement(t, "term", name, element, index); 3854 if (element.hasIdentifier()) 3855 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 3856 if (element.hasIssuedElement()) 3857 composeDateTime(t, "Contract", "issued", element.getIssuedElement(), -1); 3858 if (element.hasApplies()) 3859 composePeriod(t, "Contract", "applies", element.getApplies(), -1); 3860 if (element.hasType()) 3861 composeCodeableConcept(t, "Contract", "type", element.getType(), -1); 3862 if (element.hasSubType()) 3863 composeCodeableConcept(t, "Contract", "subType", element.getSubType(), -1); 3864 for (int i = 0; i < element.getTopic().size(); i++) 3865 composeReference(t, "Contract", "topic", element.getTopic().get(i), i); 3866 for (int i = 0; i < element.getAction().size(); i++) 3867 composeCodeableConcept(t, "Contract", "action", element.getAction().get(i), i); 3868 for (int i = 0; i < element.getActionReason().size(); i++) 3869 composeCodeableConcept(t, "Contract", "actionReason", element.getActionReason().get(i), i); 3870 for (int i = 0; i < element.getAgent().size(); i++) 3871 composeContractTermAgentComponent(t, "Contract", "agent", element.getAgent().get(i), i); 3872 if (element.hasTextElement()) 3873 composeString(t, "Contract", "text", element.getTextElement(), -1); 3874 for (int i = 0; i < element.getValuedItem().size(); i++) 3875 composeContractTermValuedItemComponent(t, "Contract", "valuedItem", element.getValuedItem().get(i), i); 3876 for (int i = 0; i < element.getGroup().size(); i++) 3877 composeContractTermComponent(t, "Contract", "group", element.getGroup().get(i), i); 3878 } 3879 3880 protected void composeContractTermAgentComponent(Complex parent, String parentType, String name, Contract.TermAgentComponent element, int index) { 3881 if (element == null) 3882 return; 3883 Complex t; 3884 if (Utilities.noString(parentType)) 3885 t = parent; 3886 else { 3887 t = parent.predicate("fhir:"+parentType+'.'+name); 3888 } 3889 composeBackboneElement(t, "agent", name, element, index); 3890 if (element.hasActor()) 3891 composeReference(t, "Contract", "actor", element.getActor(), -1); 3892 for (int i = 0; i < element.getRole().size(); i++) 3893 composeCodeableConcept(t, "Contract", "role", element.getRole().get(i), i); 3894 } 3895 3896 protected void composeContractTermValuedItemComponent(Complex parent, String parentType, String name, Contract.TermValuedItemComponent element, int index) { 3897 if (element == null) 3898 return; 3899 Complex t; 3900 if (Utilities.noString(parentType)) 3901 t = parent; 3902 else { 3903 t = parent.predicate("fhir:"+parentType+'.'+name); 3904 } 3905 composeBackboneElement(t, "valuedItem", name, element, index); 3906 if (element.hasEntity()) 3907 composeType(t, "Contract", "entity", element.getEntity(), -1); 3908 if (element.hasIdentifier()) 3909 composeIdentifier(t, "Contract", "identifier", element.getIdentifier(), -1); 3910 if (element.hasEffectiveTimeElement()) 3911 composeDateTime(t, "Contract", "effectiveTime", element.getEffectiveTimeElement(), -1); 3912 if (element.hasQuantity()) 3913 composeQuantity(t, "Contract", "quantity", element.getQuantity(), -1); 3914 if (element.hasUnitPrice()) 3915 composeQuantity(t, "Contract", "unitPrice", element.getUnitPrice(), -1); 3916 if (element.hasFactorElement()) 3917 composeDecimal(t, "Contract", "factor", element.getFactorElement(), -1); 3918 if (element.hasPointsElement()) 3919 composeDecimal(t, "Contract", "points", element.getPointsElement(), -1); 3920 if (element.hasNet()) 3921 composeQuantity(t, "Contract", "net", element.getNet(), -1); 3922 } 3923 3924 protected void composeContractFriendlyLanguageComponent(Complex parent, String parentType, String name, Contract.FriendlyLanguageComponent element, int index) { 3925 if (element == null) 3926 return; 3927 Complex t; 3928 if (Utilities.noString(parentType)) 3929 t = parent; 3930 else { 3931 t = parent.predicate("fhir:"+parentType+'.'+name); 3932 } 3933 composeBackboneElement(t, "friendly", name, element, index); 3934 if (element.hasContent()) 3935 composeType(t, "Contract", "content", element.getContent(), -1); 3936 } 3937 3938 protected void composeContractLegalLanguageComponent(Complex parent, String parentType, String name, Contract.LegalLanguageComponent element, int index) { 3939 if (element == null) 3940 return; 3941 Complex t; 3942 if (Utilities.noString(parentType)) 3943 t = parent; 3944 else { 3945 t = parent.predicate("fhir:"+parentType+'.'+name); 3946 } 3947 composeBackboneElement(t, "legal", name, element, index); 3948 if (element.hasContent()) 3949 composeType(t, "Contract", "content", element.getContent(), -1); 3950 } 3951 3952 protected void composeContractComputableLanguageComponent(Complex parent, String parentType, String name, Contract.ComputableLanguageComponent element, int index) { 3953 if (element == null) 3954 return; 3955 Complex t; 3956 if (Utilities.noString(parentType)) 3957 t = parent; 3958 else { 3959 t = parent.predicate("fhir:"+parentType+'.'+name); 3960 } 3961 composeBackboneElement(t, "rule", name, element, index); 3962 if (element.hasContent()) 3963 composeType(t, "Contract", "content", element.getContent(), -1); 3964 } 3965 3966 protected void composeCoverage(Complex parent, String parentType, String name, Coverage element, int index) { 3967 if (element == null) 3968 return; 3969 Complex t; 3970 if (Utilities.noString(parentType)) 3971 t = parent; 3972 else { 3973 t = parent.predicate("fhir:"+parentType+'.'+name); 3974 } 3975 composeDomainResource(t, "Coverage", name, element, index); 3976 if (element.hasIssuer()) 3977 composeType(t, "Coverage", "issuer", element.getIssuer(), -1); 3978 if (element.hasBinElement()) 3979 composeString(t, "Coverage", "bin", element.getBinElement(), -1); 3980 if (element.hasPeriod()) 3981 composePeriod(t, "Coverage", "period", element.getPeriod(), -1); 3982 if (element.hasType()) 3983 composeCoding(t, "Coverage", "type", element.getType(), -1); 3984 if (element.hasPlanholder()) 3985 composeType(t, "Coverage", "planholder", element.getPlanholder(), -1); 3986 if (element.hasBeneficiary()) 3987 composeType(t, "Coverage", "beneficiary", element.getBeneficiary(), -1); 3988 if (element.hasRelationship()) 3989 composeCoding(t, "Coverage", "relationship", element.getRelationship(), -1); 3990 for (int i = 0; i < element.getIdentifier().size(); i++) 3991 composeIdentifier(t, "Coverage", "identifier", element.getIdentifier().get(i), i); 3992 if (element.hasGroupElement()) 3993 composeString(t, "Coverage", "group", element.getGroupElement(), -1); 3994 if (element.hasPlanElement()) 3995 composeString(t, "Coverage", "plan", element.getPlanElement(), -1); 3996 if (element.hasSubPlanElement()) 3997 composeString(t, "Coverage", "subPlan", element.getSubPlanElement(), -1); 3998 if (element.hasDependentElement()) 3999 composePositiveInt(t, "Coverage", "dependent", element.getDependentElement(), -1); 4000 if (element.hasSequenceElement()) 4001 composePositiveInt(t, "Coverage", "sequence", element.getSequenceElement(), -1); 4002 for (int i = 0; i < element.getException().size(); i++) 4003 composeCoding(t, "Coverage", "exception", element.getException().get(i), i); 4004 if (element.hasSchoolElement()) 4005 composeString(t, "Coverage", "school", element.getSchoolElement(), -1); 4006 if (element.hasNetworkElement()) 4007 composeString(t, "Coverage", "network", element.getNetworkElement(), -1); 4008 for (int i = 0; i < element.getContract().size(); i++) 4009 composeReference(t, "Coverage", "contract", element.getContract().get(i), i); 4010 } 4011 4012 protected void composeDataElement(Complex parent, String parentType, String name, DataElement element, int index) { 4013 if (element == null) 4014 return; 4015 Complex t; 4016 if (Utilities.noString(parentType)) 4017 t = parent; 4018 else { 4019 t = parent.predicate("fhir:"+parentType+'.'+name); 4020 } 4021 composeDomainResource(t, "DataElement", name, element, index); 4022 if (element.hasUrlElement()) 4023 composeUri(t, "DataElement", "url", element.getUrlElement(), -1); 4024 for (int i = 0; i < element.getIdentifier().size(); i++) 4025 composeIdentifier(t, "DataElement", "identifier", element.getIdentifier().get(i), i); 4026 if (element.hasVersionElement()) 4027 composeString(t, "DataElement", "version", element.getVersionElement(), -1); 4028 if (element.hasStatusElement()) 4029 composeEnum(t, "DataElement", "status", element.getStatusElement(), -1); 4030 if (element.hasExperimentalElement()) 4031 composeBoolean(t, "DataElement", "experimental", element.getExperimentalElement(), -1); 4032 if (element.hasPublisherElement()) 4033 composeString(t, "DataElement", "publisher", element.getPublisherElement(), -1); 4034 if (element.hasDateElement()) 4035 composeDateTime(t, "DataElement", "date", element.getDateElement(), -1); 4036 if (element.hasNameElement()) 4037 composeString(t, "DataElement", "name", element.getNameElement(), -1); 4038 for (int i = 0; i < element.getContact().size(); i++) 4039 composeDataElementDataElementContactComponent(t, "DataElement", "contact", element.getContact().get(i), i); 4040 for (int i = 0; i < element.getUseContext().size(); i++) 4041 composeCodeableConcept(t, "DataElement", "useContext", element.getUseContext().get(i), i); 4042 if (element.hasCopyrightElement()) 4043 composeString(t, "DataElement", "copyright", element.getCopyrightElement(), -1); 4044 if (element.hasStringencyElement()) 4045 composeEnum(t, "DataElement", "stringency", element.getStringencyElement(), -1); 4046 for (int i = 0; i < element.getMapping().size(); i++) 4047 composeDataElementDataElementMappingComponent(t, "DataElement", "mapping", element.getMapping().get(i), i); 4048 for (int i = 0; i < element.getElement().size(); i++) 4049 composeElementDefinition(t, "DataElement", "element", element.getElement().get(i), i); 4050 } 4051 4052 protected void composeDataElementDataElementContactComponent(Complex parent, String parentType, String name, DataElement.DataElementContactComponent element, int index) { 4053 if (element == null) 4054 return; 4055 Complex t; 4056 if (Utilities.noString(parentType)) 4057 t = parent; 4058 else { 4059 t = parent.predicate("fhir:"+parentType+'.'+name); 4060 } 4061 composeBackboneElement(t, "contact", name, element, index); 4062 if (element.hasNameElement()) 4063 composeString(t, "DataElement", "name", element.getNameElement(), -1); 4064 for (int i = 0; i < element.getTelecom().size(); i++) 4065 composeContactPoint(t, "DataElement", "telecom", element.getTelecom().get(i), i); 4066 } 4067 4068 protected void composeDataElementDataElementMappingComponent(Complex parent, String parentType, String name, DataElement.DataElementMappingComponent element, int index) { 4069 if (element == null) 4070 return; 4071 Complex t; 4072 if (Utilities.noString(parentType)) 4073 t = parent; 4074 else { 4075 t = parent.predicate("fhir:"+parentType+'.'+name); 4076 } 4077 composeBackboneElement(t, "mapping", name, element, index); 4078 if (element.hasIdentityElement()) 4079 composeId(t, "DataElement", "identity", element.getIdentityElement(), -1); 4080 if (element.hasUriElement()) 4081 composeUri(t, "DataElement", "uri", element.getUriElement(), -1); 4082 if (element.hasNameElement()) 4083 composeString(t, "DataElement", "name", element.getNameElement(), -1); 4084 if (element.hasCommentElement()) 4085 composeString(t, "DataElement", "comment", element.getCommentElement(), -1); 4086 } 4087 4088 protected void composeDecisionSupportRule(Complex parent, String parentType, String name, DecisionSupportRule element, int index) { 4089 if (element == null) 4090 return; 4091 Complex t; 4092 if (Utilities.noString(parentType)) 4093 t = parent; 4094 else { 4095 t = parent.predicate("fhir:"+parentType+'.'+name); 4096 } 4097 composeDomainResource(t, "DecisionSupportRule", name, element, index); 4098 if (element.hasModuleMetadata()) 4099 composeModuleMetadata(t, "DecisionSupportRule", "moduleMetadata", element.getModuleMetadata(), -1); 4100 for (int i = 0; i < element.getLibrary().size(); i++) 4101 composeReference(t, "DecisionSupportRule", "library", element.getLibrary().get(i), i); 4102 for (int i = 0; i < element.getTrigger().size(); i++) 4103 composeTriggerDefinition(t, "DecisionSupportRule", "trigger", element.getTrigger().get(i), i); 4104 if (element.hasConditionElement()) 4105 composeString(t, "DecisionSupportRule", "condition", element.getConditionElement(), -1); 4106 for (int i = 0; i < element.getAction().size(); i++) 4107 composeActionDefinition(t, "DecisionSupportRule", "action", element.getAction().get(i), i); 4108 } 4109 4110 protected void composeDecisionSupportServiceModule(Complex parent, String parentType, String name, DecisionSupportServiceModule element, int index) { 4111 if (element == null) 4112 return; 4113 Complex t; 4114 if (Utilities.noString(parentType)) 4115 t = parent; 4116 else { 4117 t = parent.predicate("fhir:"+parentType+'.'+name); 4118 } 4119 composeDomainResource(t, "DecisionSupportServiceModule", name, element, index); 4120 if (element.hasModuleMetadata()) 4121 composeModuleMetadata(t, "DecisionSupportServiceModule", "moduleMetadata", element.getModuleMetadata(), -1); 4122 for (int i = 0; i < element.getTrigger().size(); i++) 4123 composeTriggerDefinition(t, "DecisionSupportServiceModule", "trigger", element.getTrigger().get(i), i); 4124 for (int i = 0; i < element.getParameter().size(); i++) 4125 composeParameterDefinition(t, "DecisionSupportServiceModule", "parameter", element.getParameter().get(i), i); 4126 for (int i = 0; i < element.getDataRequirement().size(); i++) 4127 composeDataRequirement(t, "DecisionSupportServiceModule", "dataRequirement", element.getDataRequirement().get(i), i); 4128 } 4129 4130 protected void composeDetectedIssue(Complex parent, String parentType, String name, DetectedIssue element, int index) { 4131 if (element == null) 4132 return; 4133 Complex t; 4134 if (Utilities.noString(parentType)) 4135 t = parent; 4136 else { 4137 t = parent.predicate("fhir:"+parentType+'.'+name); 4138 } 4139 composeDomainResource(t, "DetectedIssue", name, element, index); 4140 if (element.hasPatient()) 4141 composeReference(t, "DetectedIssue", "patient", element.getPatient(), -1); 4142 if (element.hasCategory()) 4143 composeCodeableConcept(t, "DetectedIssue", "category", element.getCategory(), -1); 4144 if (element.hasSeverityElement()) 4145 composeEnum(t, "DetectedIssue", "severity", element.getSeverityElement(), -1); 4146 for (int i = 0; i < element.getImplicated().size(); i++) 4147 composeReference(t, "DetectedIssue", "implicated", element.getImplicated().get(i), i); 4148 if (element.hasDetailElement()) 4149 composeString(t, "DetectedIssue", "detail", element.getDetailElement(), -1); 4150 if (element.hasDateElement()) 4151 composeDateTime(t, "DetectedIssue", "date", element.getDateElement(), -1); 4152 if (element.hasAuthor()) 4153 composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1); 4154 if (element.hasIdentifier()) 4155 composeIdentifier(t, "DetectedIssue", "identifier", element.getIdentifier(), -1); 4156 if (element.hasReferenceElement()) 4157 composeUri(t, "DetectedIssue", "reference", element.getReferenceElement(), -1); 4158 for (int i = 0; i < element.getMitigation().size(); i++) 4159 composeDetectedIssueDetectedIssueMitigationComponent(t, "DetectedIssue", "mitigation", element.getMitigation().get(i), i); 4160 } 4161 4162 protected void composeDetectedIssueDetectedIssueMitigationComponent(Complex parent, String parentType, String name, DetectedIssue.DetectedIssueMitigationComponent element, int index) { 4163 if (element == null) 4164 return; 4165 Complex t; 4166 if (Utilities.noString(parentType)) 4167 t = parent; 4168 else { 4169 t = parent.predicate("fhir:"+parentType+'.'+name); 4170 } 4171 composeBackboneElement(t, "mitigation", name, element, index); 4172 if (element.hasAction()) 4173 composeCodeableConcept(t, "DetectedIssue", "action", element.getAction(), -1); 4174 if (element.hasDateElement()) 4175 composeDateTime(t, "DetectedIssue", "date", element.getDateElement(), -1); 4176 if (element.hasAuthor()) 4177 composeReference(t, "DetectedIssue", "author", element.getAuthor(), -1); 4178 } 4179 4180 protected void composeDevice(Complex parent, String parentType, String name, Device element, int index) { 4181 if (element == null) 4182 return; 4183 Complex t; 4184 if (Utilities.noString(parentType)) 4185 t = parent; 4186 else { 4187 t = parent.predicate("fhir:"+parentType+'.'+name); 4188 } 4189 composeDomainResource(t, "Device", name, element, index); 4190 for (int i = 0; i < element.getIdentifier().size(); i++) 4191 composeIdentifier(t, "Device", "identifier", element.getIdentifier().get(i), i); 4192 if (element.hasUdiCarrier()) 4193 composeIdentifier(t, "Device", "udiCarrier", element.getUdiCarrier(), -1); 4194 if (element.hasStatusElement()) 4195 composeEnum(t, "Device", "status", element.getStatusElement(), -1); 4196 if (element.hasType()) 4197 composeCodeableConcept(t, "Device", "type", element.getType(), -1); 4198 if (element.hasLotNumberElement()) 4199 composeString(t, "Device", "lotNumber", element.getLotNumberElement(), -1); 4200 if (element.hasManufacturerElement()) 4201 composeString(t, "Device", "manufacturer", element.getManufacturerElement(), -1); 4202 if (element.hasManufactureDateElement()) 4203 composeDateTime(t, "Device", "manufactureDate", element.getManufactureDateElement(), -1); 4204 if (element.hasExpirationDateElement()) 4205 composeDateTime(t, "Device", "expirationDate", element.getExpirationDateElement(), -1); 4206 if (element.hasModelElement()) 4207 composeString(t, "Device", "model", element.getModelElement(), -1); 4208 if (element.hasVersionElement()) 4209 composeString(t, "Device", "version", element.getVersionElement(), -1); 4210 if (element.hasPatient()) 4211 composeReference(t, "Device", "patient", element.getPatient(), -1); 4212 if (element.hasOwner()) 4213 composeReference(t, "Device", "owner", element.getOwner(), -1); 4214 for (int i = 0; i < element.getContact().size(); i++) 4215 composeContactPoint(t, "Device", "contact", element.getContact().get(i), i); 4216 if (element.hasLocation()) 4217 composeReference(t, "Device", "location", element.getLocation(), -1); 4218 if (element.hasUrlElement()) 4219 composeUri(t, "Device", "url", element.getUrlElement(), -1); 4220 for (int i = 0; i < element.getNote().size(); i++) 4221 composeAnnotation(t, "Device", "note", element.getNote().get(i), i); 4222 } 4223 4224 protected void composeDeviceComponent(Complex parent, String parentType, String name, DeviceComponent element, int index) { 4225 if (element == null) 4226 return; 4227 Complex t; 4228 if (Utilities.noString(parentType)) 4229 t = parent; 4230 else { 4231 t = parent.predicate("fhir:"+parentType+'.'+name); 4232 } 4233 composeDomainResource(t, "DeviceComponent", name, element, index); 4234 if (element.hasType()) 4235 composeCodeableConcept(t, "DeviceComponent", "type", element.getType(), -1); 4236 if (element.hasIdentifier()) 4237 composeIdentifier(t, "DeviceComponent", "identifier", element.getIdentifier(), -1); 4238 if (element.hasLastSystemChangeElement()) 4239 composeInstant(t, "DeviceComponent", "lastSystemChange", element.getLastSystemChangeElement(), -1); 4240 if (element.hasSource()) 4241 composeReference(t, "DeviceComponent", "source", element.getSource(), -1); 4242 if (element.hasParent()) 4243 composeReference(t, "DeviceComponent", "parent", element.getParent(), -1); 4244 for (int i = 0; i < element.getOperationalStatus().size(); i++) 4245 composeCodeableConcept(t, "DeviceComponent", "operationalStatus", element.getOperationalStatus().get(i), i); 4246 if (element.hasParameterGroup()) 4247 composeCodeableConcept(t, "DeviceComponent", "parameterGroup", element.getParameterGroup(), -1); 4248 if (element.hasMeasurementPrincipleElement()) 4249 composeEnum(t, "DeviceComponent", "measurementPrinciple", element.getMeasurementPrincipleElement(), -1); 4250 for (int i = 0; i < element.getProductionSpecification().size(); i++) 4251 composeDeviceComponentDeviceComponentProductionSpecificationComponent(t, "DeviceComponent", "productionSpecification", element.getProductionSpecification().get(i), i); 4252 if (element.hasLanguageCode()) 4253 composeCodeableConcept(t, "DeviceComponent", "languageCode", element.getLanguageCode(), -1); 4254 } 4255 4256 protected void composeDeviceComponentDeviceComponentProductionSpecificationComponent(Complex parent, String parentType, String name, DeviceComponent.DeviceComponentProductionSpecificationComponent element, int index) { 4257 if (element == null) 4258 return; 4259 Complex t; 4260 if (Utilities.noString(parentType)) 4261 t = parent; 4262 else { 4263 t = parent.predicate("fhir:"+parentType+'.'+name); 4264 } 4265 composeBackboneElement(t, "productionSpecification", name, element, index); 4266 if (element.hasSpecType()) 4267 composeCodeableConcept(t, "DeviceComponent", "specType", element.getSpecType(), -1); 4268 if (element.hasComponentId()) 4269 composeIdentifier(t, "DeviceComponent", "componentId", element.getComponentId(), -1); 4270 if (element.hasProductionSpecElement()) 4271 composeString(t, "DeviceComponent", "productionSpec", element.getProductionSpecElement(), -1); 4272 } 4273 4274 protected void composeDeviceMetric(Complex parent, String parentType, String name, DeviceMetric element, int index) { 4275 if (element == null) 4276 return; 4277 Complex t; 4278 if (Utilities.noString(parentType)) 4279 t = parent; 4280 else { 4281 t = parent.predicate("fhir:"+parentType+'.'+name); 4282 } 4283 composeDomainResource(t, "DeviceMetric", name, element, index); 4284 if (element.hasType()) 4285 composeCodeableConcept(t, "DeviceMetric", "type", element.getType(), -1); 4286 if (element.hasIdentifier()) 4287 composeIdentifier(t, "DeviceMetric", "identifier", element.getIdentifier(), -1); 4288 if (element.hasUnit()) 4289 composeCodeableConcept(t, "DeviceMetric", "unit", element.getUnit(), -1); 4290 if (element.hasSource()) 4291 composeReference(t, "DeviceMetric", "source", element.getSource(), -1); 4292 if (element.hasParent()) 4293 composeReference(t, "DeviceMetric", "parent", element.getParent(), -1); 4294 if (element.hasOperationalStatusElement()) 4295 composeEnum(t, "DeviceMetric", "operationalStatus", element.getOperationalStatusElement(), -1); 4296 if (element.hasColorElement()) 4297 composeEnum(t, "DeviceMetric", "color", element.getColorElement(), -1); 4298 if (element.hasCategoryElement()) 4299 composeEnum(t, "DeviceMetric", "category", element.getCategoryElement(), -1); 4300 if (element.hasMeasurementPeriod()) 4301 composeTiming(t, "DeviceMetric", "measurementPeriod", element.getMeasurementPeriod(), -1); 4302 for (int i = 0; i < element.getCalibration().size(); i++) 4303 composeDeviceMetricDeviceMetricCalibrationComponent(t, "DeviceMetric", "calibration", element.getCalibration().get(i), i); 4304 } 4305 4306 protected void composeDeviceMetricDeviceMetricCalibrationComponent(Complex parent, String parentType, String name, DeviceMetric.DeviceMetricCalibrationComponent element, int index) { 4307 if (element == null) 4308 return; 4309 Complex t; 4310 if (Utilities.noString(parentType)) 4311 t = parent; 4312 else { 4313 t = parent.predicate("fhir:"+parentType+'.'+name); 4314 } 4315 composeBackboneElement(t, "calibration", name, element, index); 4316 if (element.hasTypeElement()) 4317 composeEnum(t, "DeviceMetric", "type", element.getTypeElement(), -1); 4318 if (element.hasStateElement()) 4319 composeEnum(t, "DeviceMetric", "state", element.getStateElement(), -1); 4320 if (element.hasTimeElement()) 4321 composeInstant(t, "DeviceMetric", "time", element.getTimeElement(), -1); 4322 } 4323 4324 protected void composeDeviceUseRequest(Complex parent, String parentType, String name, DeviceUseRequest element, int index) { 4325 if (element == null) 4326 return; 4327 Complex t; 4328 if (Utilities.noString(parentType)) 4329 t = parent; 4330 else { 4331 t = parent.predicate("fhir:"+parentType+'.'+name); 4332 } 4333 composeDomainResource(t, "DeviceUseRequest", name, element, index); 4334 if (element.hasBodySite()) 4335 composeType(t, "DeviceUseRequest", "bodySite", element.getBodySite(), -1); 4336 if (element.hasStatusElement()) 4337 composeEnum(t, "DeviceUseRequest", "status", element.getStatusElement(), -1); 4338 if (element.hasDevice()) 4339 composeReference(t, "DeviceUseRequest", "device", element.getDevice(), -1); 4340 if (element.hasEncounter()) 4341 composeReference(t, "DeviceUseRequest", "encounter", element.getEncounter(), -1); 4342 for (int i = 0; i < element.getIdentifier().size(); i++) 4343 composeIdentifier(t, "DeviceUseRequest", "identifier", element.getIdentifier().get(i), i); 4344 for (int i = 0; i < element.getIndication().size(); i++) 4345 composeCodeableConcept(t, "DeviceUseRequest", "indication", element.getIndication().get(i), i); 4346 for (int i = 0; i < element.getNotes().size(); i++) 4347 composeString(t, "DeviceUseRequest", "notes", element.getNotes().get(i), i); 4348 for (int i = 0; i < element.getPrnReason().size(); i++) 4349 composeCodeableConcept(t, "DeviceUseRequest", "prnReason", element.getPrnReason().get(i), i); 4350 if (element.hasOrderedOnElement()) 4351 composeDateTime(t, "DeviceUseRequest", "orderedOn", element.getOrderedOnElement(), -1); 4352 if (element.hasRecordedOnElement()) 4353 composeDateTime(t, "DeviceUseRequest", "recordedOn", element.getRecordedOnElement(), -1); 4354 if (element.hasSubject()) 4355 composeReference(t, "DeviceUseRequest", "subject", element.getSubject(), -1); 4356 if (element.hasTiming()) 4357 composeType(t, "DeviceUseRequest", "timing", element.getTiming(), -1); 4358 if (element.hasPriorityElement()) 4359 composeEnum(t, "DeviceUseRequest", "priority", element.getPriorityElement(), -1); 4360 } 4361 4362 protected void composeDeviceUseStatement(Complex parent, String parentType, String name, DeviceUseStatement element, int index) { 4363 if (element == null) 4364 return; 4365 Complex t; 4366 if (Utilities.noString(parentType)) 4367 t = parent; 4368 else { 4369 t = parent.predicate("fhir:"+parentType+'.'+name); 4370 } 4371 composeDomainResource(t, "DeviceUseStatement", name, element, index); 4372 if (element.hasBodySite()) 4373 composeType(t, "DeviceUseStatement", "bodySite", element.getBodySite(), -1); 4374 if (element.hasWhenUsed()) 4375 composePeriod(t, "DeviceUseStatement", "whenUsed", element.getWhenUsed(), -1); 4376 if (element.hasDevice()) 4377 composeReference(t, "DeviceUseStatement", "device", element.getDevice(), -1); 4378 for (int i = 0; i < element.getIdentifier().size(); i++) 4379 composeIdentifier(t, "DeviceUseStatement", "identifier", element.getIdentifier().get(i), i); 4380 for (int i = 0; i < element.getIndication().size(); i++) 4381 composeCodeableConcept(t, "DeviceUseStatement", "indication", element.getIndication().get(i), i); 4382 for (int i = 0; i < element.getNotes().size(); i++) 4383 composeString(t, "DeviceUseStatement", "notes", element.getNotes().get(i), i); 4384 if (element.hasRecordedOnElement()) 4385 composeDateTime(t, "DeviceUseStatement", "recordedOn", element.getRecordedOnElement(), -1); 4386 if (element.hasSubject()) 4387 composeReference(t, "DeviceUseStatement", "subject", element.getSubject(), -1); 4388 if (element.hasTiming()) 4389 composeType(t, "DeviceUseStatement", "timing", element.getTiming(), -1); 4390 } 4391 4392 protected void composeDiagnosticOrder(Complex parent, String parentType, String name, DiagnosticOrder element, int index) { 4393 if (element == null) 4394 return; 4395 Complex t; 4396 if (Utilities.noString(parentType)) 4397 t = parent; 4398 else { 4399 t = parent.predicate("fhir:"+parentType+'.'+name); 4400 } 4401 composeDomainResource(t, "DiagnosticOrder", name, element, index); 4402 for (int i = 0; i < element.getIdentifier().size(); i++) 4403 composeIdentifier(t, "DiagnosticOrder", "identifier", element.getIdentifier().get(i), i); 4404 if (element.hasStatusElement()) 4405 composeEnum(t, "DiagnosticOrder", "status", element.getStatusElement(), -1); 4406 if (element.hasPriorityElement()) 4407 composeEnum(t, "DiagnosticOrder", "priority", element.getPriorityElement(), -1); 4408 if (element.hasSubject()) 4409 composeReference(t, "DiagnosticOrder", "subject", element.getSubject(), -1); 4410 if (element.hasEncounter()) 4411 composeReference(t, "DiagnosticOrder", "encounter", element.getEncounter(), -1); 4412 if (element.hasOrderer()) 4413 composeReference(t, "DiagnosticOrder", "orderer", element.getOrderer(), -1); 4414 for (int i = 0; i < element.getReason().size(); i++) 4415 composeCodeableConcept(t, "DiagnosticOrder", "reason", element.getReason().get(i), i); 4416 for (int i = 0; i < element.getSupportingInformation().size(); i++) 4417 composeReference(t, "DiagnosticOrder", "supportingInformation", element.getSupportingInformation().get(i), i); 4418 for (int i = 0; i < element.getSpecimen().size(); i++) 4419 composeReference(t, "DiagnosticOrder", "specimen", element.getSpecimen().get(i), i); 4420 for (int i = 0; i < element.getEvent().size(); i++) 4421 composeDiagnosticOrderDiagnosticOrderEventComponent(t, "DiagnosticOrder", "event", element.getEvent().get(i), i); 4422 for (int i = 0; i < element.getItem().size(); i++) 4423 composeDiagnosticOrderDiagnosticOrderItemComponent(t, "DiagnosticOrder", "item", element.getItem().get(i), i); 4424 for (int i = 0; i < element.getNote().size(); i++) 4425 composeAnnotation(t, "DiagnosticOrder", "note", element.getNote().get(i), i); 4426 } 4427 4428 protected void composeDiagnosticOrderDiagnosticOrderEventComponent(Complex parent, String parentType, String name, DiagnosticOrder.DiagnosticOrderEventComponent element, int index) { 4429 if (element == null) 4430 return; 4431 Complex t; 4432 if (Utilities.noString(parentType)) 4433 t = parent; 4434 else { 4435 t = parent.predicate("fhir:"+parentType+'.'+name); 4436 } 4437 composeBackboneElement(t, "event", name, element, index); 4438 if (element.hasStatusElement()) 4439 composeEnum(t, "DiagnosticOrder", "status", element.getStatusElement(), -1); 4440 if (element.hasDescription()) 4441 composeCodeableConcept(t, "DiagnosticOrder", "description", element.getDescription(), -1); 4442 if (element.hasDateTimeElement()) 4443 composeDateTime(t, "DiagnosticOrder", "dateTime", element.getDateTimeElement(), -1); 4444 if (element.hasActor()) 4445 composeReference(t, "DiagnosticOrder", "actor", element.getActor(), -1); 4446 } 4447 4448 protected void composeDiagnosticOrderDiagnosticOrderItemComponent(Complex parent, String parentType, String name, DiagnosticOrder.DiagnosticOrderItemComponent element, int index) { 4449 if (element == null) 4450 return; 4451 Complex t; 4452 if (Utilities.noString(parentType)) 4453 t = parent; 4454 else { 4455 t = parent.predicate("fhir:"+parentType+'.'+name); 4456 } 4457 composeBackboneElement(t, "item", name, element, index); 4458 if (element.hasCode()) 4459 composeCodeableConcept(t, "DiagnosticOrder", "code", element.getCode(), -1); 4460 for (int i = 0; i < element.getSpecimen().size(); i++) 4461 composeReference(t, "DiagnosticOrder", "specimen", element.getSpecimen().get(i), i); 4462 if (element.hasBodySite()) 4463 composeCodeableConcept(t, "DiagnosticOrder", "bodySite", element.getBodySite(), -1); 4464 if (element.hasStatusElement()) 4465 composeEnum(t, "DiagnosticOrder", "status", element.getStatusElement(), -1); 4466 for (int i = 0; i < element.getEvent().size(); i++) 4467 composeDiagnosticOrderDiagnosticOrderEventComponent(t, "DiagnosticOrder", "event", element.getEvent().get(i), i); 4468 } 4469 4470 protected void composeDiagnosticReport(Complex parent, String parentType, String name, DiagnosticReport element, int index) { 4471 if (element == null) 4472 return; 4473 Complex t; 4474 if (Utilities.noString(parentType)) 4475 t = parent; 4476 else { 4477 t = parent.predicate("fhir:"+parentType+'.'+name); 4478 } 4479 composeDomainResource(t, "DiagnosticReport", name, element, index); 4480 for (int i = 0; i < element.getIdentifier().size(); i++) 4481 composeIdentifier(t, "DiagnosticReport", "identifier", element.getIdentifier().get(i), i); 4482 if (element.hasStatusElement()) 4483 composeEnum(t, "DiagnosticReport", "status", element.getStatusElement(), -1); 4484 if (element.hasCategory()) 4485 composeCodeableConcept(t, "DiagnosticReport", "category", element.getCategory(), -1); 4486 if (element.hasCode()) 4487 composeCodeableConcept(t, "DiagnosticReport", "code", element.getCode(), -1); 4488 if (element.hasSubject()) 4489 composeReference(t, "DiagnosticReport", "subject", element.getSubject(), -1); 4490 if (element.hasEncounter()) 4491 composeReference(t, "DiagnosticReport", "encounter", element.getEncounter(), -1); 4492 if (element.hasEffective()) 4493 composeType(t, "DiagnosticReport", "effective", element.getEffective(), -1); 4494 if (element.hasIssuedElement()) 4495 composeInstant(t, "DiagnosticReport", "issued", element.getIssuedElement(), -1); 4496 if (element.hasPerformer()) 4497 composeReference(t, "DiagnosticReport", "performer", element.getPerformer(), -1); 4498 for (int i = 0; i < element.getRequest().size(); i++) 4499 composeReference(t, "DiagnosticReport", "request", element.getRequest().get(i), i); 4500 for (int i = 0; i < element.getSpecimen().size(); i++) 4501 composeReference(t, "DiagnosticReport", "specimen", element.getSpecimen().get(i), i); 4502 for (int i = 0; i < element.getResult().size(); i++) 4503 composeReference(t, "DiagnosticReport", "result", element.getResult().get(i), i); 4504 for (int i = 0; i < element.getImagingStudy().size(); i++) 4505 composeReference(t, "DiagnosticReport", "imagingStudy", element.getImagingStudy().get(i), i); 4506 for (int i = 0; i < element.getImage().size(); i++) 4507 composeDiagnosticReportDiagnosticReportImageComponent(t, "DiagnosticReport", "image", element.getImage().get(i), i); 4508 if (element.hasConclusionElement()) 4509 composeString(t, "DiagnosticReport", "conclusion", element.getConclusionElement(), -1); 4510 for (int i = 0; i < element.getCodedDiagnosis().size(); i++) 4511 composeCodeableConcept(t, "DiagnosticReport", "codedDiagnosis", element.getCodedDiagnosis().get(i), i); 4512 for (int i = 0; i < element.getPresentedForm().size(); i++) 4513 composeAttachment(t, "DiagnosticReport", "presentedForm", element.getPresentedForm().get(i), i); 4514 } 4515 4516 protected void composeDiagnosticReportDiagnosticReportImageComponent(Complex parent, String parentType, String name, DiagnosticReport.DiagnosticReportImageComponent element, int index) { 4517 if (element == null) 4518 return; 4519 Complex t; 4520 if (Utilities.noString(parentType)) 4521 t = parent; 4522 else { 4523 t = parent.predicate("fhir:"+parentType+'.'+name); 4524 } 4525 composeBackboneElement(t, "image", name, element, index); 4526 if (element.hasCommentElement()) 4527 composeString(t, "DiagnosticReport", "comment", element.getCommentElement(), -1); 4528 if (element.hasLink()) 4529 composeReference(t, "DiagnosticReport", "link", element.getLink(), -1); 4530 } 4531 4532 protected void composeDocumentManifest(Complex parent, String parentType, String name, DocumentManifest element, int index) { 4533 if (element == null) 4534 return; 4535 Complex t; 4536 if (Utilities.noString(parentType)) 4537 t = parent; 4538 else { 4539 t = parent.predicate("fhir:"+parentType+'.'+name); 4540 } 4541 composeDomainResource(t, "DocumentManifest", name, element, index); 4542 if (element.hasMasterIdentifier()) 4543 composeIdentifier(t, "DocumentManifest", "masterIdentifier", element.getMasterIdentifier(), -1); 4544 for (int i = 0; i < element.getIdentifier().size(); i++) 4545 composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier().get(i), i); 4546 if (element.hasSubject()) 4547 composeReference(t, "DocumentManifest", "subject", element.getSubject(), -1); 4548 for (int i = 0; i < element.getRecipient().size(); i++) 4549 composeReference(t, "DocumentManifest", "recipient", element.getRecipient().get(i), i); 4550 if (element.hasType()) 4551 composeCodeableConcept(t, "DocumentManifest", "type", element.getType(), -1); 4552 for (int i = 0; i < element.getAuthor().size(); i++) 4553 composeReference(t, "DocumentManifest", "author", element.getAuthor().get(i), i); 4554 if (element.hasCreatedElement()) 4555 composeDateTime(t, "DocumentManifest", "created", element.getCreatedElement(), -1); 4556 if (element.hasSourceElement()) 4557 composeUri(t, "DocumentManifest", "source", element.getSourceElement(), -1); 4558 if (element.hasStatusElement()) 4559 composeEnum(t, "DocumentManifest", "status", element.getStatusElement(), -1); 4560 if (element.hasDescriptionElement()) 4561 composeString(t, "DocumentManifest", "description", element.getDescriptionElement(), -1); 4562 for (int i = 0; i < element.getContent().size(); i++) 4563 composeDocumentManifestDocumentManifestContentComponent(t, "DocumentManifest", "content", element.getContent().get(i), i); 4564 for (int i = 0; i < element.getRelated().size(); i++) 4565 composeDocumentManifestDocumentManifestRelatedComponent(t, "DocumentManifest", "related", element.getRelated().get(i), i); 4566 } 4567 4568 protected void composeDocumentManifestDocumentManifestContentComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestContentComponent element, int index) { 4569 if (element == null) 4570 return; 4571 Complex t; 4572 if (Utilities.noString(parentType)) 4573 t = parent; 4574 else { 4575 t = parent.predicate("fhir:"+parentType+'.'+name); 4576 } 4577 composeBackboneElement(t, "content", name, element, index); 4578 if (element.hasP()) 4579 composeType(t, "DocumentManifest", "p", element.getP(), -1); 4580 } 4581 4582 protected void composeDocumentManifestDocumentManifestRelatedComponent(Complex parent, String parentType, String name, DocumentManifest.DocumentManifestRelatedComponent element, int index) { 4583 if (element == null) 4584 return; 4585 Complex t; 4586 if (Utilities.noString(parentType)) 4587 t = parent; 4588 else { 4589 t = parent.predicate("fhir:"+parentType+'.'+name); 4590 } 4591 composeBackboneElement(t, "related", name, element, index); 4592 if (element.hasIdentifier()) 4593 composeIdentifier(t, "DocumentManifest", "identifier", element.getIdentifier(), -1); 4594 if (element.hasRef()) 4595 composeReference(t, "DocumentManifest", "ref", element.getRef(), -1); 4596 } 4597 4598 protected void composeDocumentReference(Complex parent, String parentType, String name, DocumentReference element, int index) { 4599 if (element == null) 4600 return; 4601 Complex t; 4602 if (Utilities.noString(parentType)) 4603 t = parent; 4604 else { 4605 t = parent.predicate("fhir:"+parentType+'.'+name); 4606 } 4607 composeDomainResource(t, "DocumentReference", name, element, index); 4608 if (element.hasMasterIdentifier()) 4609 composeIdentifier(t, "DocumentReference", "masterIdentifier", element.getMasterIdentifier(), -1); 4610 for (int i = 0; i < element.getIdentifier().size(); i++) 4611 composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier().get(i), i); 4612 if (element.hasSubject()) 4613 composeReference(t, "DocumentReference", "subject", element.getSubject(), -1); 4614 if (element.hasType()) 4615 composeCodeableConcept(t, "DocumentReference", "type", element.getType(), -1); 4616 if (element.hasClass_()) 4617 composeCodeableConcept(t, "DocumentReference", "class", element.getClass_(), -1); 4618 for (int i = 0; i < element.getAuthor().size(); i++) 4619 composeReference(t, "DocumentReference", "author", element.getAuthor().get(i), i); 4620 if (element.hasCustodian()) 4621 composeReference(t, "DocumentReference", "custodian", element.getCustodian(), -1); 4622 if (element.hasAuthenticator()) 4623 composeReference(t, "DocumentReference", "authenticator", element.getAuthenticator(), -1); 4624 if (element.hasCreatedElement()) 4625 composeDateTime(t, "DocumentReference", "created", element.getCreatedElement(), -1); 4626 if (element.hasIndexedElement()) 4627 composeInstant(t, "DocumentReference", "indexed", element.getIndexedElement(), -1); 4628 if (element.hasStatusElement()) 4629 composeEnum(t, "DocumentReference", "status", element.getStatusElement(), -1); 4630 if (element.hasDocStatus()) 4631 composeCodeableConcept(t, "DocumentReference", "docStatus", element.getDocStatus(), -1); 4632 for (int i = 0; i < element.getRelatesTo().size(); i++) 4633 composeDocumentReferenceDocumentReferenceRelatesToComponent(t, "DocumentReference", "relatesTo", element.getRelatesTo().get(i), i); 4634 if (element.hasDescriptionElement()) 4635 composeString(t, "DocumentReference", "description", element.getDescriptionElement(), -1); 4636 for (int i = 0; i < element.getSecurityLabel().size(); i++) 4637 composeCodeableConcept(t, "DocumentReference", "securityLabel", element.getSecurityLabel().get(i), i); 4638 for (int i = 0; i < element.getContent().size(); i++) 4639 composeDocumentReferenceDocumentReferenceContentComponent(t, "DocumentReference", "content", element.getContent().get(i), i); 4640 if (element.hasContext()) 4641 composeDocumentReferenceDocumentReferenceContextComponent(t, "DocumentReference", "context", element.getContext(), -1); 4642 } 4643 4644 protected void composeDocumentReferenceDocumentReferenceRelatesToComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceRelatesToComponent element, int index) { 4645 if (element == null) 4646 return; 4647 Complex t; 4648 if (Utilities.noString(parentType)) 4649 t = parent; 4650 else { 4651 t = parent.predicate("fhir:"+parentType+'.'+name); 4652 } 4653 composeBackboneElement(t, "relatesTo", name, element, index); 4654 if (element.hasCodeElement()) 4655 composeEnum(t, "DocumentReference", "code", element.getCodeElement(), -1); 4656 if (element.hasTarget()) 4657 composeReference(t, "DocumentReference", "target", element.getTarget(), -1); 4658 } 4659 4660 protected void composeDocumentReferenceDocumentReferenceContentComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContentComponent element, int index) { 4661 if (element == null) 4662 return; 4663 Complex t; 4664 if (Utilities.noString(parentType)) 4665 t = parent; 4666 else { 4667 t = parent.predicate("fhir:"+parentType+'.'+name); 4668 } 4669 composeBackboneElement(t, "content", name, element, index); 4670 if (element.hasAttachment()) 4671 composeAttachment(t, "DocumentReference", "attachment", element.getAttachment(), -1); 4672 for (int i = 0; i < element.getFormat().size(); i++) 4673 composeCoding(t, "DocumentReference", "format", element.getFormat().get(i), i); 4674 } 4675 4676 protected void composeDocumentReferenceDocumentReferenceContextComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextComponent element, int index) { 4677 if (element == null) 4678 return; 4679 Complex t; 4680 if (Utilities.noString(parentType)) 4681 t = parent; 4682 else { 4683 t = parent.predicate("fhir:"+parentType+'.'+name); 4684 } 4685 composeBackboneElement(t, "context", name, element, index); 4686 if (element.hasEncounter()) 4687 composeReference(t, "DocumentReference", "encounter", element.getEncounter(), -1); 4688 for (int i = 0; i < element.getEvent().size(); i++) 4689 composeCodeableConcept(t, "DocumentReference", "event", element.getEvent().get(i), i); 4690 if (element.hasPeriod()) 4691 composePeriod(t, "DocumentReference", "period", element.getPeriod(), -1); 4692 if (element.hasFacilityType()) 4693 composeCodeableConcept(t, "DocumentReference", "facilityType", element.getFacilityType(), -1); 4694 if (element.hasPracticeSetting()) 4695 composeCodeableConcept(t, "DocumentReference", "practiceSetting", element.getPracticeSetting(), -1); 4696 if (element.hasSourcePatientInfo()) 4697 composeReference(t, "DocumentReference", "sourcePatientInfo", element.getSourcePatientInfo(), -1); 4698 for (int i = 0; i < element.getRelated().size(); i++) 4699 composeDocumentReferenceDocumentReferenceContextRelatedComponent(t, "DocumentReference", "related", element.getRelated().get(i), i); 4700 } 4701 4702 protected void composeDocumentReferenceDocumentReferenceContextRelatedComponent(Complex parent, String parentType, String name, DocumentReference.DocumentReferenceContextRelatedComponent element, int index) { 4703 if (element == null) 4704 return; 4705 Complex t; 4706 if (Utilities.noString(parentType)) 4707 t = parent; 4708 else { 4709 t = parent.predicate("fhir:"+parentType+'.'+name); 4710 } 4711 composeBackboneElement(t, "related", name, element, index); 4712 if (element.hasIdentifier()) 4713 composeIdentifier(t, "DocumentReference", "identifier", element.getIdentifier(), -1); 4714 if (element.hasRef()) 4715 composeReference(t, "DocumentReference", "ref", element.getRef(), -1); 4716 } 4717 4718 protected void composeEligibilityRequest(Complex parent, String parentType, String name, EligibilityRequest element, int index) { 4719 if (element == null) 4720 return; 4721 Complex t; 4722 if (Utilities.noString(parentType)) 4723 t = parent; 4724 else { 4725 t = parent.predicate("fhir:"+parentType+'.'+name); 4726 } 4727 composeDomainResource(t, "EligibilityRequest", name, element, index); 4728 for (int i = 0; i < element.getIdentifier().size(); i++) 4729 composeIdentifier(t, "EligibilityRequest", "identifier", element.getIdentifier().get(i), i); 4730 if (element.hasRuleset()) 4731 composeCoding(t, "EligibilityRequest", "ruleset", element.getRuleset(), -1); 4732 if (element.hasOriginalRuleset()) 4733 composeCoding(t, "EligibilityRequest", "originalRuleset", element.getOriginalRuleset(), -1); 4734 if (element.hasCreatedElement()) 4735 composeDateTime(t, "EligibilityRequest", "created", element.getCreatedElement(), -1); 4736 if (element.hasTarget()) 4737 composeType(t, "EligibilityRequest", "target", element.getTarget(), -1); 4738 if (element.hasProvider()) 4739 composeType(t, "EligibilityRequest", "provider", element.getProvider(), -1); 4740 if (element.hasOrganization()) 4741 composeType(t, "EligibilityRequest", "organization", element.getOrganization(), -1); 4742 if (element.hasPriority()) 4743 composeCoding(t, "EligibilityRequest", "priority", element.getPriority(), -1); 4744 if (element.hasEnterer()) 4745 composeType(t, "EligibilityRequest", "enterer", element.getEnterer(), -1); 4746 if (element.hasFacility()) 4747 composeType(t, "EligibilityRequest", "facility", element.getFacility(), -1); 4748 if (element.hasPatient()) 4749 composeType(t, "EligibilityRequest", "patient", element.getPatient(), -1); 4750 if (element.hasCoverage()) 4751 composeType(t, "EligibilityRequest", "coverage", element.getCoverage(), -1); 4752 if (element.hasBusinessArrangementElement()) 4753 composeString(t, "EligibilityRequest", "businessArrangement", element.getBusinessArrangementElement(), -1); 4754 if (element.hasServiced()) 4755 composeType(t, "EligibilityRequest", "serviced", element.getServiced(), -1); 4756 if (element.hasBenefitCategory()) 4757 composeCoding(t, "EligibilityRequest", "benefitCategory", element.getBenefitCategory(), -1); 4758 if (element.hasBenefitSubCategory()) 4759 composeCoding(t, "EligibilityRequest", "benefitSubCategory", element.getBenefitSubCategory(), -1); 4760 } 4761 4762 protected void composeEligibilityResponse(Complex parent, String parentType, String name, EligibilityResponse element, int index) { 4763 if (element == null) 4764 return; 4765 Complex t; 4766 if (Utilities.noString(parentType)) 4767 t = parent; 4768 else { 4769 t = parent.predicate("fhir:"+parentType+'.'+name); 4770 } 4771 composeDomainResource(t, "EligibilityResponse", name, element, index); 4772 for (int i = 0; i < element.getIdentifier().size(); i++) 4773 composeIdentifier(t, "EligibilityResponse", "identifier", element.getIdentifier().get(i), i); 4774 if (element.hasRequest()) 4775 composeType(t, "EligibilityResponse", "request", element.getRequest(), -1); 4776 if (element.hasOutcomeElement()) 4777 composeEnum(t, "EligibilityResponse", "outcome", element.getOutcomeElement(), -1); 4778 if (element.hasDispositionElement()) 4779 composeString(t, "EligibilityResponse", "disposition", element.getDispositionElement(), -1); 4780 if (element.hasRuleset()) 4781 composeCoding(t, "EligibilityResponse", "ruleset", element.getRuleset(), -1); 4782 if (element.hasOriginalRuleset()) 4783 composeCoding(t, "EligibilityResponse", "originalRuleset", element.getOriginalRuleset(), -1); 4784 if (element.hasCreatedElement()) 4785 composeDateTime(t, "EligibilityResponse", "created", element.getCreatedElement(), -1); 4786 if (element.hasOrganization()) 4787 composeType(t, "EligibilityResponse", "organization", element.getOrganization(), -1); 4788 if (element.hasRequestProvider()) 4789 composeType(t, "EligibilityResponse", "requestProvider", element.getRequestProvider(), -1); 4790 if (element.hasRequestOrganization()) 4791 composeType(t, "EligibilityResponse", "requestOrganization", element.getRequestOrganization(), -1); 4792 if (element.hasInforceElement()) 4793 composeBoolean(t, "EligibilityResponse", "inforce", element.getInforceElement(), -1); 4794 if (element.hasContract()) 4795 composeReference(t, "EligibilityResponse", "contract", element.getContract(), -1); 4796 if (element.hasForm()) 4797 composeCoding(t, "EligibilityResponse", "form", element.getForm(), -1); 4798 for (int i = 0; i < element.getBenefitBalance().size(); i++) 4799 composeEligibilityResponseBenefitsComponent(t, "EligibilityResponse", "benefitBalance", element.getBenefitBalance().get(i), i); 4800 for (int i = 0; i < element.getError().size(); i++) 4801 composeEligibilityResponseErrorsComponent(t, "EligibilityResponse", "error", element.getError().get(i), i); 4802 } 4803 4804 protected void composeEligibilityResponseBenefitsComponent(Complex parent, String parentType, String name, EligibilityResponse.BenefitsComponent element, int index) { 4805 if (element == null) 4806 return; 4807 Complex t; 4808 if (Utilities.noString(parentType)) 4809 t = parent; 4810 else { 4811 t = parent.predicate("fhir:"+parentType+'.'+name); 4812 } 4813 composeBackboneElement(t, "benefitBalance", name, element, index); 4814 if (element.hasCategory()) 4815 composeCoding(t, "EligibilityResponse", "category", element.getCategory(), -1); 4816 if (element.hasSubCategory()) 4817 composeCoding(t, "EligibilityResponse", "subCategory", element.getSubCategory(), -1); 4818 if (element.hasNetwork()) 4819 composeCoding(t, "EligibilityResponse", "network", element.getNetwork(), -1); 4820 if (element.hasUnit()) 4821 composeCoding(t, "EligibilityResponse", "unit", element.getUnit(), -1); 4822 if (element.hasTerm()) 4823 composeCoding(t, "EligibilityResponse", "term", element.getTerm(), -1); 4824 for (int i = 0; i < element.getFinancial().size(); i++) 4825 composeEligibilityResponseBenefitComponent(t, "EligibilityResponse", "financial", element.getFinancial().get(i), i); 4826 } 4827 4828 protected void composeEligibilityResponseBenefitComponent(Complex parent, String parentType, String name, EligibilityResponse.BenefitComponent element, int index) { 4829 if (element == null) 4830 return; 4831 Complex t; 4832 if (Utilities.noString(parentType)) 4833 t = parent; 4834 else { 4835 t = parent.predicate("fhir:"+parentType+'.'+name); 4836 } 4837 composeBackboneElement(t, "financial", name, element, index); 4838 if (element.hasType()) 4839 composeCoding(t, "EligibilityResponse", "type", element.getType(), -1); 4840 if (element.hasBenefit()) 4841 composeType(t, "EligibilityResponse", "benefit", element.getBenefit(), -1); 4842 if (element.hasBenefitUsed()) 4843 composeType(t, "EligibilityResponse", "benefitUsed", element.getBenefitUsed(), -1); 4844 } 4845 4846 protected void composeEligibilityResponseErrorsComponent(Complex parent, String parentType, String name, EligibilityResponse.ErrorsComponent element, int index) { 4847 if (element == null) 4848 return; 4849 Complex t; 4850 if (Utilities.noString(parentType)) 4851 t = parent; 4852 else { 4853 t = parent.predicate("fhir:"+parentType+'.'+name); 4854 } 4855 composeBackboneElement(t, "error", name, element, index); 4856 if (element.hasCode()) 4857 composeCoding(t, "EligibilityResponse", "code", element.getCode(), -1); 4858 } 4859 4860 protected void composeEncounter(Complex parent, String parentType, String name, Encounter element, int index) { 4861 if (element == null) 4862 return; 4863 Complex t; 4864 if (Utilities.noString(parentType)) 4865 t = parent; 4866 else { 4867 t = parent.predicate("fhir:"+parentType+'.'+name); 4868 } 4869 composeDomainResource(t, "Encounter", name, element, index); 4870 for (int i = 0; i < element.getIdentifier().size(); i++) 4871 composeIdentifier(t, "Encounter", "identifier", element.getIdentifier().get(i), i); 4872 if (element.hasStatusElement()) 4873 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 4874 for (int i = 0; i < element.getStatusHistory().size(); i++) 4875 composeEncounterEncounterStatusHistoryComponent(t, "Encounter", "statusHistory", element.getStatusHistory().get(i), i); 4876 if (element.hasClass_Element()) 4877 composeEnum(t, "Encounter", "class", element.getClass_Element(), -1); 4878 for (int i = 0; i < element.getType().size(); i++) 4879 composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i); 4880 if (element.hasPriority()) 4881 composeCodeableConcept(t, "Encounter", "priority", element.getPriority(), -1); 4882 if (element.hasPatient()) 4883 composeReference(t, "Encounter", "patient", element.getPatient(), -1); 4884 for (int i = 0; i < element.getEpisodeOfCare().size(); i++) 4885 composeReference(t, "Encounter", "episodeOfCare", element.getEpisodeOfCare().get(i), i); 4886 for (int i = 0; i < element.getIncomingReferral().size(); i++) 4887 composeReference(t, "Encounter", "incomingReferral", element.getIncomingReferral().get(i), i); 4888 for (int i = 0; i < element.getParticipant().size(); i++) 4889 composeEncounterEncounterParticipantComponent(t, "Encounter", "participant", element.getParticipant().get(i), i); 4890 if (element.hasAppointment()) 4891 composeReference(t, "Encounter", "appointment", element.getAppointment(), -1); 4892 if (element.hasPeriod()) 4893 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 4894 if (element.hasLength()) 4895 composeQuantity(t, "Encounter", "length", element.getLength(), -1); 4896 for (int i = 0; i < element.getReason().size(); i++) 4897 composeCodeableConcept(t, "Encounter", "reason", element.getReason().get(i), i); 4898 for (int i = 0; i < element.getIndication().size(); i++) 4899 composeReference(t, "Encounter", "indication", element.getIndication().get(i), i); 4900 if (element.hasHospitalization()) 4901 composeEncounterEncounterHospitalizationComponent(t, "Encounter", "hospitalization", element.getHospitalization(), -1); 4902 for (int i = 0; i < element.getLocation().size(); i++) 4903 composeEncounterEncounterLocationComponent(t, "Encounter", "location", element.getLocation().get(i), i); 4904 if (element.hasServiceProvider()) 4905 composeReference(t, "Encounter", "serviceProvider", element.getServiceProvider(), -1); 4906 if (element.hasPartOf()) 4907 composeReference(t, "Encounter", "partOf", element.getPartOf(), -1); 4908 } 4909 4910 protected void composeEncounterEncounterStatusHistoryComponent(Complex parent, String parentType, String name, Encounter.EncounterStatusHistoryComponent element, int index) { 4911 if (element == null) 4912 return; 4913 Complex t; 4914 if (Utilities.noString(parentType)) 4915 t = parent; 4916 else { 4917 t = parent.predicate("fhir:"+parentType+'.'+name); 4918 } 4919 composeBackboneElement(t, "statusHistory", name, element, index); 4920 if (element.hasStatusElement()) 4921 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 4922 if (element.hasPeriod()) 4923 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 4924 } 4925 4926 protected void composeEncounterEncounterParticipantComponent(Complex parent, String parentType, String name, Encounter.EncounterParticipantComponent element, int index) { 4927 if (element == null) 4928 return; 4929 Complex t; 4930 if (Utilities.noString(parentType)) 4931 t = parent; 4932 else { 4933 t = parent.predicate("fhir:"+parentType+'.'+name); 4934 } 4935 composeBackboneElement(t, "participant", name, element, index); 4936 for (int i = 0; i < element.getType().size(); i++) 4937 composeCodeableConcept(t, "Encounter", "type", element.getType().get(i), i); 4938 if (element.hasPeriod()) 4939 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 4940 if (element.hasIndividual()) 4941 composeReference(t, "Encounter", "individual", element.getIndividual(), -1); 4942 } 4943 4944 protected void composeEncounterEncounterHospitalizationComponent(Complex parent, String parentType, String name, Encounter.EncounterHospitalizationComponent element, int index) { 4945 if (element == null) 4946 return; 4947 Complex t; 4948 if (Utilities.noString(parentType)) 4949 t = parent; 4950 else { 4951 t = parent.predicate("fhir:"+parentType+'.'+name); 4952 } 4953 composeBackboneElement(t, "hospitalization", name, element, index); 4954 if (element.hasPreAdmissionIdentifier()) 4955 composeIdentifier(t, "Encounter", "preAdmissionIdentifier", element.getPreAdmissionIdentifier(), -1); 4956 if (element.hasOrigin()) 4957 composeReference(t, "Encounter", "origin", element.getOrigin(), -1); 4958 if (element.hasAdmitSource()) 4959 composeCodeableConcept(t, "Encounter", "admitSource", element.getAdmitSource(), -1); 4960 for (int i = 0; i < element.getAdmittingDiagnosis().size(); i++) 4961 composeReference(t, "Encounter", "admittingDiagnosis", element.getAdmittingDiagnosis().get(i), i); 4962 if (element.hasReAdmission()) 4963 composeCodeableConcept(t, "Encounter", "reAdmission", element.getReAdmission(), -1); 4964 for (int i = 0; i < element.getDietPreference().size(); i++) 4965 composeCodeableConcept(t, "Encounter", "dietPreference", element.getDietPreference().get(i), i); 4966 for (int i = 0; i < element.getSpecialCourtesy().size(); i++) 4967 composeCodeableConcept(t, "Encounter", "specialCourtesy", element.getSpecialCourtesy().get(i), i); 4968 for (int i = 0; i < element.getSpecialArrangement().size(); i++) 4969 composeCodeableConcept(t, "Encounter", "specialArrangement", element.getSpecialArrangement().get(i), i); 4970 if (element.hasDestination()) 4971 composeReference(t, "Encounter", "destination", element.getDestination(), -1); 4972 if (element.hasDischargeDisposition()) 4973 composeCodeableConcept(t, "Encounter", "dischargeDisposition", element.getDischargeDisposition(), -1); 4974 for (int i = 0; i < element.getDischargeDiagnosis().size(); i++) 4975 composeReference(t, "Encounter", "dischargeDiagnosis", element.getDischargeDiagnosis().get(i), i); 4976 } 4977 4978 protected void composeEncounterEncounterLocationComponent(Complex parent, String parentType, String name, Encounter.EncounterLocationComponent element, int index) { 4979 if (element == null) 4980 return; 4981 Complex t; 4982 if (Utilities.noString(parentType)) 4983 t = parent; 4984 else { 4985 t = parent.predicate("fhir:"+parentType+'.'+name); 4986 } 4987 composeBackboneElement(t, "location", name, element, index); 4988 if (element.hasLocation()) 4989 composeReference(t, "Encounter", "location", element.getLocation(), -1); 4990 if (element.hasStatusElement()) 4991 composeEnum(t, "Encounter", "status", element.getStatusElement(), -1); 4992 if (element.hasPeriod()) 4993 composePeriod(t, "Encounter", "period", element.getPeriod(), -1); 4994 } 4995 4996 protected void composeEnrollmentRequest(Complex parent, String parentType, String name, EnrollmentRequest element, int index) { 4997 if (element == null) 4998 return; 4999 Complex t; 5000 if (Utilities.noString(parentType)) 5001 t = parent; 5002 else { 5003 t = parent.predicate("fhir:"+parentType+'.'+name); 5004 } 5005 composeDomainResource(t, "EnrollmentRequest", name, element, index); 5006 for (int i = 0; i < element.getIdentifier().size(); i++) 5007 composeIdentifier(t, "EnrollmentRequest", "identifier", element.getIdentifier().get(i), i); 5008 if (element.hasRuleset()) 5009 composeCoding(t, "EnrollmentRequest", "ruleset", element.getRuleset(), -1); 5010 if (element.hasOriginalRuleset()) 5011 composeCoding(t, "EnrollmentRequest", "originalRuleset", element.getOriginalRuleset(), -1); 5012 if (element.hasCreatedElement()) 5013 composeDateTime(t, "EnrollmentRequest", "created", element.getCreatedElement(), -1); 5014 if (element.hasTarget()) 5015 composeReference(t, "EnrollmentRequest", "target", element.getTarget(), -1); 5016 if (element.hasProvider()) 5017 composeReference(t, "EnrollmentRequest", "provider", element.getProvider(), -1); 5018 if (element.hasOrganization()) 5019 composeReference(t, "EnrollmentRequest", "organization", element.getOrganization(), -1); 5020 if (element.hasSubject()) 5021 composeReference(t, "EnrollmentRequest", "subject", element.getSubject(), -1); 5022 if (element.hasCoverage()) 5023 composeReference(t, "EnrollmentRequest", "coverage", element.getCoverage(), -1); 5024 if (element.hasRelationship()) 5025 composeCoding(t, "EnrollmentRequest", "relationship", element.getRelationship(), -1); 5026 } 5027 5028 protected void composeEnrollmentResponse(Complex parent, String parentType, String name, EnrollmentResponse element, int index) { 5029 if (element == null) 5030 return; 5031 Complex t; 5032 if (Utilities.noString(parentType)) 5033 t = parent; 5034 else { 5035 t = parent.predicate("fhir:"+parentType+'.'+name); 5036 } 5037 composeDomainResource(t, "EnrollmentResponse", name, element, index); 5038 for (int i = 0; i < element.getIdentifier().size(); i++) 5039 composeIdentifier(t, "EnrollmentResponse", "identifier", element.getIdentifier().get(i), i); 5040 if (element.hasRequest()) 5041 composeReference(t, "EnrollmentResponse", "request", element.getRequest(), -1); 5042 if (element.hasOutcomeElement()) 5043 composeEnum(t, "EnrollmentResponse", "outcome", element.getOutcomeElement(), -1); 5044 if (element.hasDispositionElement()) 5045 composeString(t, "EnrollmentResponse", "disposition", element.getDispositionElement(), -1); 5046 if (element.hasRuleset()) 5047 composeCoding(t, "EnrollmentResponse", "ruleset", element.getRuleset(), -1); 5048 if (element.hasOriginalRuleset()) 5049 composeCoding(t, "EnrollmentResponse", "originalRuleset", element.getOriginalRuleset(), -1); 5050 if (element.hasCreatedElement()) 5051 composeDateTime(t, "EnrollmentResponse", "created", element.getCreatedElement(), -1); 5052 if (element.hasOrganization()) 5053 composeReference(t, "EnrollmentResponse", "organization", element.getOrganization(), -1); 5054 if (element.hasRequestProvider()) 5055 composeReference(t, "EnrollmentResponse", "requestProvider", element.getRequestProvider(), -1); 5056 if (element.hasRequestOrganization()) 5057 composeReference(t, "EnrollmentResponse", "requestOrganization", element.getRequestOrganization(), -1); 5058 } 5059 5060 protected void composeEpisodeOfCare(Complex parent, String parentType, String name, EpisodeOfCare element, int index) { 5061 if (element == null) 5062 return; 5063 Complex t; 5064 if (Utilities.noString(parentType)) 5065 t = parent; 5066 else { 5067 t = parent.predicate("fhir:"+parentType+'.'+name); 5068 } 5069 composeDomainResource(t, "EpisodeOfCare", name, element, index); 5070 for (int i = 0; i < element.getIdentifier().size(); i++) 5071 composeIdentifier(t, "EpisodeOfCare", "identifier", element.getIdentifier().get(i), i); 5072 if (element.hasStatusElement()) 5073 composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1); 5074 for (int i = 0; i < element.getStatusHistory().size(); i++) 5075 composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(t, "EpisodeOfCare", "statusHistory", element.getStatusHistory().get(i), i); 5076 for (int i = 0; i < element.getType().size(); i++) 5077 composeCodeableConcept(t, "EpisodeOfCare", "type", element.getType().get(i), i); 5078 for (int i = 0; i < element.getCondition().size(); i++) 5079 composeReference(t, "EpisodeOfCare", "condition", element.getCondition().get(i), i); 5080 if (element.hasPatient()) 5081 composeReference(t, "EpisodeOfCare", "patient", element.getPatient(), -1); 5082 if (element.hasManagingOrganization()) 5083 composeReference(t, "EpisodeOfCare", "managingOrganization", element.getManagingOrganization(), -1); 5084 if (element.hasPeriod()) 5085 composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1); 5086 for (int i = 0; i < element.getReferralRequest().size(); i++) 5087 composeReference(t, "EpisodeOfCare", "referralRequest", element.getReferralRequest().get(i), i); 5088 if (element.hasCareManager()) 5089 composeReference(t, "EpisodeOfCare", "careManager", element.getCareManager(), -1); 5090 for (int i = 0; i < element.getTeam().size(); i++) 5091 composeReference(t, "EpisodeOfCare", "team", element.getTeam().get(i), i); 5092 } 5093 5094 protected void composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(Complex parent, String parentType, String name, EpisodeOfCare.EpisodeOfCareStatusHistoryComponent element, int index) { 5095 if (element == null) 5096 return; 5097 Complex t; 5098 if (Utilities.noString(parentType)) 5099 t = parent; 5100 else { 5101 t = parent.predicate("fhir:"+parentType+'.'+name); 5102 } 5103 composeBackboneElement(t, "statusHistory", name, element, index); 5104 if (element.hasStatusElement()) 5105 composeEnum(t, "EpisodeOfCare", "status", element.getStatusElement(), -1); 5106 if (element.hasPeriod()) 5107 composePeriod(t, "EpisodeOfCare", "period", element.getPeriod(), -1); 5108 } 5109 5110 protected void composeExpansionProfile(Complex parent, String parentType, String name, ExpansionProfile element, int index) { 5111 if (element == null) 5112 return; 5113 Complex t; 5114 if (Utilities.noString(parentType)) 5115 t = parent; 5116 else { 5117 t = parent.predicate("fhir:"+parentType+'.'+name); 5118 } 5119 composeDomainResource(t, "ExpansionProfile", name, element, index); 5120 if (element.hasUrlElement()) 5121 composeUri(t, "ExpansionProfile", "url", element.getUrlElement(), -1); 5122 if (element.hasIdentifier()) 5123 composeIdentifier(t, "ExpansionProfile", "identifier", element.getIdentifier(), -1); 5124 if (element.hasVersionElement()) 5125 composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1); 5126 if (element.hasNameElement()) 5127 composeString(t, "ExpansionProfile", "name", element.getNameElement(), -1); 5128 if (element.hasStatusElement()) 5129 composeEnum(t, "ExpansionProfile", "status", element.getStatusElement(), -1); 5130 if (element.hasExperimentalElement()) 5131 composeBoolean(t, "ExpansionProfile", "experimental", element.getExperimentalElement(), -1); 5132 if (element.hasPublisherElement()) 5133 composeString(t, "ExpansionProfile", "publisher", element.getPublisherElement(), -1); 5134 for (int i = 0; i < element.getContact().size(); i++) 5135 composeExpansionProfileExpansionProfileContactComponent(t, "ExpansionProfile", "contact", element.getContact().get(i), i); 5136 if (element.hasDateElement()) 5137 composeDateTime(t, "ExpansionProfile", "date", element.getDateElement(), -1); 5138 if (element.hasDescriptionElement()) 5139 composeString(t, "ExpansionProfile", "description", element.getDescriptionElement(), -1); 5140 if (element.hasCodeSystem()) 5141 composeExpansionProfileExpansionProfileCodeSystemComponent(t, "ExpansionProfile", "codeSystem", element.getCodeSystem(), -1); 5142 if (element.hasIncludeDesignationsElement()) 5143 composeBoolean(t, "ExpansionProfile", "includeDesignations", element.getIncludeDesignationsElement(), -1); 5144 if (element.hasDesignation()) 5145 composeExpansionProfileExpansionProfileDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation(), -1); 5146 if (element.hasIncludeDefinitionElement()) 5147 composeBoolean(t, "ExpansionProfile", "includeDefinition", element.getIncludeDefinitionElement(), -1); 5148 if (element.hasIncludeInactiveElement()) 5149 composeBoolean(t, "ExpansionProfile", "includeInactive", element.getIncludeInactiveElement(), -1); 5150 if (element.hasExcludeNestedElement()) 5151 composeBoolean(t, "ExpansionProfile", "excludeNested", element.getExcludeNestedElement(), -1); 5152 if (element.hasExcludeNotForUIElement()) 5153 composeBoolean(t, "ExpansionProfile", "excludeNotForUI", element.getExcludeNotForUIElement(), -1); 5154 if (element.hasExcludePostCoordinatedElement()) 5155 composeBoolean(t, "ExpansionProfile", "excludePostCoordinated", element.getExcludePostCoordinatedElement(), -1); 5156 if (element.hasDisplayLanguageElement()) 5157 composeCode(t, "ExpansionProfile", "displayLanguage", element.getDisplayLanguageElement(), -1); 5158 if (element.hasLimitedExpansionElement()) 5159 composeBoolean(t, "ExpansionProfile", "limitedExpansion", element.getLimitedExpansionElement(), -1); 5160 } 5161 5162 protected void composeExpansionProfileExpansionProfileContactComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileContactComponent element, int index) { 5163 if (element == null) 5164 return; 5165 Complex t; 5166 if (Utilities.noString(parentType)) 5167 t = parent; 5168 else { 5169 t = parent.predicate("fhir:"+parentType+'.'+name); 5170 } 5171 composeBackboneElement(t, "contact", name, element, index); 5172 if (element.hasNameElement()) 5173 composeString(t, "ExpansionProfile", "name", element.getNameElement(), -1); 5174 for (int i = 0; i < element.getTelecom().size(); i++) 5175 composeContactPoint(t, "ExpansionProfile", "telecom", element.getTelecom().get(i), i); 5176 } 5177 5178 protected void composeExpansionProfileExpansionProfileCodeSystemComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileCodeSystemComponent element, int index) { 5179 if (element == null) 5180 return; 5181 Complex t; 5182 if (Utilities.noString(parentType)) 5183 t = parent; 5184 else { 5185 t = parent.predicate("fhir:"+parentType+'.'+name); 5186 } 5187 composeBackboneElement(t, "codeSystem", name, element, index); 5188 if (element.hasInclude()) 5189 composeExpansionProfileCodeSystemIncludeComponent(t, "ExpansionProfile", "include", element.getInclude(), -1); 5190 if (element.hasExclude()) 5191 composeExpansionProfileCodeSystemExcludeComponent(t, "ExpansionProfile", "exclude", element.getExclude(), -1); 5192 } 5193 5194 protected void composeExpansionProfileCodeSystemIncludeComponent(Complex parent, String parentType, String name, ExpansionProfile.CodeSystemIncludeComponent element, int index) { 5195 if (element == null) 5196 return; 5197 Complex t; 5198 if (Utilities.noString(parentType)) 5199 t = parent; 5200 else { 5201 t = parent.predicate("fhir:"+parentType+'.'+name); 5202 } 5203 composeBackboneElement(t, "include", name, element, index); 5204 for (int i = 0; i < element.getCodeSystem().size(); i++) 5205 composeExpansionProfileCodeSystemIncludeCodeSystemComponent(t, "ExpansionProfile", "codeSystem", element.getCodeSystem().get(i), i); 5206 } 5207 5208 protected void composeExpansionProfileCodeSystemIncludeCodeSystemComponent(Complex parent, String parentType, String name, ExpansionProfile.CodeSystemIncludeCodeSystemComponent element, int index) { 5209 if (element == null) 5210 return; 5211 Complex t; 5212 if (Utilities.noString(parentType)) 5213 t = parent; 5214 else { 5215 t = parent.predicate("fhir:"+parentType+'.'+name); 5216 } 5217 composeBackboneElement(t, "codeSystem", name, element, index); 5218 if (element.hasSystemElement()) 5219 composeUri(t, "ExpansionProfile", "system", element.getSystemElement(), -1); 5220 if (element.hasVersionElement()) 5221 composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1); 5222 } 5223 5224 protected void composeExpansionProfileCodeSystemExcludeComponent(Complex parent, String parentType, String name, ExpansionProfile.CodeSystemExcludeComponent element, int index) { 5225 if (element == null) 5226 return; 5227 Complex t; 5228 if (Utilities.noString(parentType)) 5229 t = parent; 5230 else { 5231 t = parent.predicate("fhir:"+parentType+'.'+name); 5232 } 5233 composeBackboneElement(t, "exclude", name, element, index); 5234 for (int i = 0; i < element.getCodeSystem().size(); i++) 5235 composeExpansionProfileCodeSystemExcludeCodeSystemComponent(t, "ExpansionProfile", "codeSystem", element.getCodeSystem().get(i), i); 5236 } 5237 5238 protected void composeExpansionProfileCodeSystemExcludeCodeSystemComponent(Complex parent, String parentType, String name, ExpansionProfile.CodeSystemExcludeCodeSystemComponent element, int index) { 5239 if (element == null) 5240 return; 5241 Complex t; 5242 if (Utilities.noString(parentType)) 5243 t = parent; 5244 else { 5245 t = parent.predicate("fhir:"+parentType+'.'+name); 5246 } 5247 composeBackboneElement(t, "codeSystem", name, element, index); 5248 if (element.hasSystemElement()) 5249 composeUri(t, "ExpansionProfile", "system", element.getSystemElement(), -1); 5250 if (element.hasVersionElement()) 5251 composeString(t, "ExpansionProfile", "version", element.getVersionElement(), -1); 5252 } 5253 5254 protected void composeExpansionProfileExpansionProfileDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.ExpansionProfileDesignationComponent element, int index) { 5255 if (element == null) 5256 return; 5257 Complex t; 5258 if (Utilities.noString(parentType)) 5259 t = parent; 5260 else { 5261 t = parent.predicate("fhir:"+parentType+'.'+name); 5262 } 5263 composeBackboneElement(t, "designation", name, element, index); 5264 if (element.hasInclude()) 5265 composeExpansionProfileDesignationIncludeComponent(t, "ExpansionProfile", "include", element.getInclude(), -1); 5266 if (element.hasExclude()) 5267 composeExpansionProfileDesignationExcludeComponent(t, "ExpansionProfile", "exclude", element.getExclude(), -1); 5268 } 5269 5270 protected void composeExpansionProfileDesignationIncludeComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationIncludeComponent element, int index) { 5271 if (element == null) 5272 return; 5273 Complex t; 5274 if (Utilities.noString(parentType)) 5275 t = parent; 5276 else { 5277 t = parent.predicate("fhir:"+parentType+'.'+name); 5278 } 5279 composeBackboneElement(t, "include", name, element, index); 5280 for (int i = 0; i < element.getDesignation().size(); i++) 5281 composeExpansionProfileDesignationIncludeDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation().get(i), i); 5282 } 5283 5284 protected void composeExpansionProfileDesignationIncludeDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationIncludeDesignationComponent element, int index) { 5285 if (element == null) 5286 return; 5287 Complex t; 5288 if (Utilities.noString(parentType)) 5289 t = parent; 5290 else { 5291 t = parent.predicate("fhir:"+parentType+'.'+name); 5292 } 5293 composeBackboneElement(t, "designation", name, element, index); 5294 if (element.hasLanguageElement()) 5295 composeCode(t, "ExpansionProfile", "language", element.getLanguageElement(), -1); 5296 if (element.hasUse()) 5297 composeCoding(t, "ExpansionProfile", "use", element.getUse(), -1); 5298 } 5299 5300 protected void composeExpansionProfileDesignationExcludeComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationExcludeComponent element, int index) { 5301 if (element == null) 5302 return; 5303 Complex t; 5304 if (Utilities.noString(parentType)) 5305 t = parent; 5306 else { 5307 t = parent.predicate("fhir:"+parentType+'.'+name); 5308 } 5309 composeBackboneElement(t, "exclude", name, element, index); 5310 for (int i = 0; i < element.getDesignation().size(); i++) 5311 composeExpansionProfileDesignationExcludeDesignationComponent(t, "ExpansionProfile", "designation", element.getDesignation().get(i), i); 5312 } 5313 5314 protected void composeExpansionProfileDesignationExcludeDesignationComponent(Complex parent, String parentType, String name, ExpansionProfile.DesignationExcludeDesignationComponent element, int index) { 5315 if (element == null) 5316 return; 5317 Complex t; 5318 if (Utilities.noString(parentType)) 5319 t = parent; 5320 else { 5321 t = parent.predicate("fhir:"+parentType+'.'+name); 5322 } 5323 composeBackboneElement(t, "designation", name, element, index); 5324 if (element.hasLanguageElement()) 5325 composeCode(t, "ExpansionProfile", "language", element.getLanguageElement(), -1); 5326 if (element.hasUse()) 5327 composeCoding(t, "ExpansionProfile", "use", element.getUse(), -1); 5328 } 5329 5330 protected void composeExplanationOfBenefit(Complex parent, String parentType, String name, ExplanationOfBenefit element, int index) { 5331 if (element == null) 5332 return; 5333 Complex t; 5334 if (Utilities.noString(parentType)) 5335 t = parent; 5336 else { 5337 t = parent.predicate("fhir:"+parentType+'.'+name); 5338 } 5339 composeDomainResource(t, "ExplanationOfBenefit", name, element, index); 5340 for (int i = 0; i < element.getIdentifier().size(); i++) 5341 composeIdentifier(t, "ExplanationOfBenefit", "identifier", element.getIdentifier().get(i), i); 5342 if (element.hasClaim()) 5343 composeType(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1); 5344 if (element.hasClaimResponse()) 5345 composeType(t, "ExplanationOfBenefit", "claimResponse", element.getClaimResponse(), -1); 5346 for (int i = 0; i < element.getSubType().size(); i++) 5347 composeCoding(t, "ExplanationOfBenefit", "subType", element.getSubType().get(i), i); 5348 if (element.hasRuleset()) 5349 composeCoding(t, "ExplanationOfBenefit", "ruleset", element.getRuleset(), -1); 5350 if (element.hasOriginalRuleset()) 5351 composeCoding(t, "ExplanationOfBenefit", "originalRuleset", element.getOriginalRuleset(), -1); 5352 if (element.hasCreatedElement()) 5353 composeDateTime(t, "ExplanationOfBenefit", "created", element.getCreatedElement(), -1); 5354 if (element.hasBillablePeriod()) 5355 composePeriod(t, "ExplanationOfBenefit", "billablePeriod", element.getBillablePeriod(), -1); 5356 if (element.hasDispositionElement()) 5357 composeString(t, "ExplanationOfBenefit", "disposition", element.getDispositionElement(), -1); 5358 if (element.hasProvider()) 5359 composeType(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1); 5360 if (element.hasOrganization()) 5361 composeType(t, "ExplanationOfBenefit", "organization", element.getOrganization(), -1); 5362 if (element.hasFacility()) 5363 composeType(t, "ExplanationOfBenefit", "facility", element.getFacility(), -1); 5364 for (int i = 0; i < element.getRelated().size(); i++) 5365 composeExplanationOfBenefitRelatedClaimsComponent(t, "ExplanationOfBenefit", "related", element.getRelated().get(i), i); 5366 if (element.hasPrescription()) 5367 composeType(t, "ExplanationOfBenefit", "prescription", element.getPrescription(), -1); 5368 if (element.hasOriginalPrescription()) 5369 composeType(t, "ExplanationOfBenefit", "originalPrescription", element.getOriginalPrescription(), -1); 5370 if (element.hasPayee()) 5371 composeExplanationOfBenefitPayeeComponent(t, "ExplanationOfBenefit", "payee", element.getPayee(), -1); 5372 if (element.hasReferral()) 5373 composeType(t, "ExplanationOfBenefit", "referral", element.getReferral(), -1); 5374 for (int i = 0; i < element.getOccurrenceCode().size(); i++) 5375 composeCoding(t, "ExplanationOfBenefit", "occurrenceCode", element.getOccurrenceCode().get(i), i); 5376 for (int i = 0; i < element.getOccurenceSpanCode().size(); i++) 5377 composeCoding(t, "ExplanationOfBenefit", "occurenceSpanCode", element.getOccurenceSpanCode().get(i), i); 5378 for (int i = 0; i < element.getValueCode().size(); i++) 5379 composeCoding(t, "ExplanationOfBenefit", "valueCode", element.getValueCode().get(i), i); 5380 for (int i = 0; i < element.getDiagnosis().size(); i++) 5381 composeExplanationOfBenefitDiagnosisComponent(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis().get(i), i); 5382 for (int i = 0; i < element.getProcedure().size(); i++) 5383 composeExplanationOfBenefitProcedureComponent(t, "ExplanationOfBenefit", "procedure", element.getProcedure().get(i), i); 5384 for (int i = 0; i < element.getSpecialCondition().size(); i++) 5385 composeCoding(t, "ExplanationOfBenefit", "specialCondition", element.getSpecialCondition().get(i), i); 5386 if (element.hasPatient()) 5387 composeType(t, "ExplanationOfBenefit", "patient", element.getPatient(), -1); 5388 if (element.hasPrecedenceElement()) 5389 composePositiveInt(t, "ExplanationOfBenefit", "precedence", element.getPrecedenceElement(), -1); 5390 if (element.hasCoverage()) 5391 composeExplanationOfBenefitCoverageComponent(t, "ExplanationOfBenefit", "coverage", element.getCoverage(), -1); 5392 if (element.hasAccidentDateElement()) 5393 composeDate(t, "ExplanationOfBenefit", "accidentDate", element.getAccidentDateElement(), -1); 5394 if (element.hasAccidentType()) 5395 composeCoding(t, "ExplanationOfBenefit", "accidentType", element.getAccidentType(), -1); 5396 if (element.hasAccidentLocation()) 5397 composeType(t, "ExplanationOfBenefit", "accidentLocation", element.getAccidentLocation(), -1); 5398 for (int i = 0; i < element.getInterventionException().size(); i++) 5399 composeCoding(t, "ExplanationOfBenefit", "interventionException", element.getInterventionException().get(i), i); 5400 for (int i = 0; i < element.getOnset().size(); i++) 5401 composeExplanationOfBenefitOnsetComponent(t, "ExplanationOfBenefit", "onset", element.getOnset().get(i), i); 5402 if (element.hasEmploymentImpacted()) 5403 composePeriod(t, "ExplanationOfBenefit", "employmentImpacted", element.getEmploymentImpacted(), -1); 5404 if (element.hasHospitalization()) 5405 composePeriod(t, "ExplanationOfBenefit", "hospitalization", element.getHospitalization(), -1); 5406 for (int i = 0; i < element.getItem().size(); i++) 5407 composeExplanationOfBenefitItemsComponent(t, "ExplanationOfBenefit", "item", element.getItem().get(i), i); 5408 for (int i = 0; i < element.getAddItem().size(); i++) 5409 composeExplanationOfBenefitAddedItemComponent(t, "ExplanationOfBenefit", "addItem", element.getAddItem().get(i), i); 5410 for (int i = 0; i < element.getMissingTeeth().size(); i++) 5411 composeExplanationOfBenefitMissingTeethComponent(t, "ExplanationOfBenefit", "missingTeeth", element.getMissingTeeth().get(i), i); 5412 if (element.hasTotalCost()) 5413 composeQuantity(t, "ExplanationOfBenefit", "totalCost", element.getTotalCost(), -1); 5414 if (element.hasUnallocDeductable()) 5415 composeQuantity(t, "ExplanationOfBenefit", "unallocDeductable", element.getUnallocDeductable(), -1); 5416 if (element.hasTotalBenefit()) 5417 composeQuantity(t, "ExplanationOfBenefit", "totalBenefit", element.getTotalBenefit(), -1); 5418 if (element.hasPaymentAdjustment()) 5419 composeQuantity(t, "ExplanationOfBenefit", "paymentAdjustment", element.getPaymentAdjustment(), -1); 5420 if (element.hasPaymentAdjustmentReason()) 5421 composeCoding(t, "ExplanationOfBenefit", "paymentAdjustmentReason", element.getPaymentAdjustmentReason(), -1); 5422 if (element.hasPaymentDateElement()) 5423 composeDate(t, "ExplanationOfBenefit", "paymentDate", element.getPaymentDateElement(), -1); 5424 if (element.hasPaymentAmount()) 5425 composeQuantity(t, "ExplanationOfBenefit", "paymentAmount", element.getPaymentAmount(), -1); 5426 if (element.hasPaymentRef()) 5427 composeIdentifier(t, "ExplanationOfBenefit", "paymentRef", element.getPaymentRef(), -1); 5428 if (element.hasReserved()) 5429 composeCoding(t, "ExplanationOfBenefit", "reserved", element.getReserved(), -1); 5430 if (element.hasForm()) 5431 composeCoding(t, "ExplanationOfBenefit", "form", element.getForm(), -1); 5432 for (int i = 0; i < element.getNote().size(); i++) 5433 composeExplanationOfBenefitNotesComponent(t, "ExplanationOfBenefit", "note", element.getNote().get(i), i); 5434 for (int i = 0; i < element.getBenefitBalance().size(); i++) 5435 composeExplanationOfBenefitBenefitBalanceComponent(t, "ExplanationOfBenefit", "benefitBalance", element.getBenefitBalance().get(i), i); 5436 } 5437 5438 protected void composeExplanationOfBenefitRelatedClaimsComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.RelatedClaimsComponent element, int index) { 5439 if (element == null) 5440 return; 5441 Complex t; 5442 if (Utilities.noString(parentType)) 5443 t = parent; 5444 else { 5445 t = parent.predicate("fhir:"+parentType+'.'+name); 5446 } 5447 composeBackboneElement(t, "related", name, element, index); 5448 if (element.hasClaim()) 5449 composeType(t, "ExplanationOfBenefit", "claim", element.getClaim(), -1); 5450 if (element.hasRelationship()) 5451 composeCoding(t, "ExplanationOfBenefit", "relationship", element.getRelationship(), -1); 5452 if (element.hasReference()) 5453 composeIdentifier(t, "ExplanationOfBenefit", "reference", element.getReference(), -1); 5454 } 5455 5456 protected void composeExplanationOfBenefitPayeeComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.PayeeComponent element, int index) { 5457 if (element == null) 5458 return; 5459 Complex t; 5460 if (Utilities.noString(parentType)) 5461 t = parent; 5462 else { 5463 t = parent.predicate("fhir:"+parentType+'.'+name); 5464 } 5465 composeBackboneElement(t, "payee", name, element, index); 5466 if (element.hasType()) 5467 composeCoding(t, "ExplanationOfBenefit", "type", element.getType(), -1); 5468 if (element.hasParty()) 5469 composeType(t, "ExplanationOfBenefit", "party", element.getParty(), -1); 5470 } 5471 5472 protected void composeExplanationOfBenefitDiagnosisComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DiagnosisComponent element, int index) { 5473 if (element == null) 5474 return; 5475 Complex t; 5476 if (Utilities.noString(parentType)) 5477 t = parent; 5478 else { 5479 t = parent.predicate("fhir:"+parentType+'.'+name); 5480 } 5481 composeBackboneElement(t, "diagnosis", name, element, index); 5482 if (element.hasSequenceElement()) 5483 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 5484 if (element.hasDiagnosis()) 5485 composeCoding(t, "ExplanationOfBenefit", "diagnosis", element.getDiagnosis(), -1); 5486 } 5487 5488 protected void composeExplanationOfBenefitProcedureComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ProcedureComponent element, int index) { 5489 if (element == null) 5490 return; 5491 Complex t; 5492 if (Utilities.noString(parentType)) 5493 t = parent; 5494 else { 5495 t = parent.predicate("fhir:"+parentType+'.'+name); 5496 } 5497 composeBackboneElement(t, "procedure", name, element, index); 5498 if (element.hasSequenceElement()) 5499 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 5500 if (element.hasDateElement()) 5501 composeDateTime(t, "ExplanationOfBenefit", "date", element.getDateElement(), -1); 5502 if (element.hasProcedure()) 5503 composeType(t, "ExplanationOfBenefit", "procedure", element.getProcedure(), -1); 5504 } 5505 5506 protected void composeExplanationOfBenefitCoverageComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.CoverageComponent element, int index) { 5507 if (element == null) 5508 return; 5509 Complex t; 5510 if (Utilities.noString(parentType)) 5511 t = parent; 5512 else { 5513 t = parent.predicate("fhir:"+parentType+'.'+name); 5514 } 5515 composeBackboneElement(t, "coverage", name, element, index); 5516 if (element.hasCoverage()) 5517 composeType(t, "ExplanationOfBenefit", "coverage", element.getCoverage(), -1); 5518 for (int i = 0; i < element.getPreAuthRef().size(); i++) 5519 composeString(t, "ExplanationOfBenefit", "preAuthRef", element.getPreAuthRef().get(i), i); 5520 } 5521 5522 protected void composeExplanationOfBenefitOnsetComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.OnsetComponent element, int index) { 5523 if (element == null) 5524 return; 5525 Complex t; 5526 if (Utilities.noString(parentType)) 5527 t = parent; 5528 else { 5529 t = parent.predicate("fhir:"+parentType+'.'+name); 5530 } 5531 composeBackboneElement(t, "onset", name, element, index); 5532 if (element.hasTime()) 5533 composeType(t, "ExplanationOfBenefit", "time", element.getTime(), -1); 5534 if (element.hasType()) 5535 composeCoding(t, "ExplanationOfBenefit", "type", element.getType(), -1); 5536 } 5537 5538 protected void composeExplanationOfBenefitItemsComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ItemsComponent element, int index) { 5539 if (element == null) 5540 return; 5541 Complex t; 5542 if (Utilities.noString(parentType)) 5543 t = parent; 5544 else { 5545 t = parent.predicate("fhir:"+parentType+'.'+name); 5546 } 5547 composeBackboneElement(t, "item", name, element, index); 5548 if (element.hasSequenceElement()) 5549 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 5550 if (element.hasType()) 5551 composeCoding(t, "ExplanationOfBenefit", "type", element.getType(), -1); 5552 if (element.hasProvider()) 5553 composeType(t, "ExplanationOfBenefit", "provider", element.getProvider(), -1); 5554 if (element.hasSupervisor()) 5555 composeType(t, "ExplanationOfBenefit", "supervisor", element.getSupervisor(), -1); 5556 if (element.hasProviderQualification()) 5557 composeCoding(t, "ExplanationOfBenefit", "providerQualification", element.getProviderQualification(), -1); 5558 for (int i = 0; i < element.getDiagnosisLinkId().size(); i++) 5559 composePositiveInt(t, "ExplanationOfBenefit", "diagnosisLinkId", element.getDiagnosisLinkId().get(i), i); 5560 if (element.hasService()) 5561 composeCoding(t, "ExplanationOfBenefit", "service", element.getService(), -1); 5562 for (int i = 0; i < element.getServiceModifier().size(); i++) 5563 composeCoding(t, "ExplanationOfBenefit", "serviceModifier", element.getServiceModifier().get(i), i); 5564 for (int i = 0; i < element.getModifier().size(); i++) 5565 composeCoding(t, "ExplanationOfBenefit", "modifier", element.getModifier().get(i), i); 5566 for (int i = 0; i < element.getProgramCode().size(); i++) 5567 composeCoding(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 5568 if (element.hasServiced()) 5569 composeType(t, "ExplanationOfBenefit", "serviced", element.getServiced(), -1); 5570 if (element.hasPlace()) 5571 composeCoding(t, "ExplanationOfBenefit", "place", element.getPlace(), -1); 5572 if (element.hasQuantity()) 5573 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 5574 if (element.hasUnitPrice()) 5575 composeQuantity(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 5576 if (element.hasFactorElement()) 5577 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 5578 if (element.hasPointsElement()) 5579 composeDecimal(t, "ExplanationOfBenefit", "points", element.getPointsElement(), -1); 5580 if (element.hasNet()) 5581 composeQuantity(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 5582 for (int i = 0; i < element.getUdi().size(); i++) 5583 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 5584 if (element.hasBodySite()) 5585 composeCoding(t, "ExplanationOfBenefit", "bodySite", element.getBodySite(), -1); 5586 for (int i = 0; i < element.getSubSite().size(); i++) 5587 composeCoding(t, "ExplanationOfBenefit", "subSite", element.getSubSite().get(i), i); 5588 for (int i = 0; i < element.getNoteNumber().size(); i++) 5589 composePositiveInt(t, "ExplanationOfBenefit", "noteNumber", element.getNoteNumber().get(i), i); 5590 for (int i = 0; i < element.getAdjudication().size(); i++) 5591 composeExplanationOfBenefitItemAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 5592 for (int i = 0; i < element.getDetail().size(); i++) 5593 composeExplanationOfBenefitDetailComponent(t, "ExplanationOfBenefit", "detail", element.getDetail().get(i), i); 5594 if (element.hasProsthesis()) 5595 composeExplanationOfBenefitProsthesisComponent(t, "ExplanationOfBenefit", "prosthesis", element.getProsthesis(), -1); 5596 } 5597 5598 protected void composeExplanationOfBenefitItemAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ItemAdjudicationComponent element, int index) { 5599 if (element == null) 5600 return; 5601 Complex t; 5602 if (Utilities.noString(parentType)) 5603 t = parent; 5604 else { 5605 t = parent.predicate("fhir:"+parentType+'.'+name); 5606 } 5607 composeBackboneElement(t, "adjudication", name, element, index); 5608 if (element.hasCategory()) 5609 composeCoding(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 5610 if (element.hasReason()) 5611 composeCoding(t, "ExplanationOfBenefit", "reason", element.getReason(), -1); 5612 if (element.hasAmount()) 5613 composeQuantity(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1); 5614 if (element.hasValueElement()) 5615 composeDecimal(t, "ExplanationOfBenefit", "value", element.getValueElement(), -1); 5616 } 5617 5618 protected void composeExplanationOfBenefitDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DetailComponent element, int index) { 5619 if (element == null) 5620 return; 5621 Complex t; 5622 if (Utilities.noString(parentType)) 5623 t = parent; 5624 else { 5625 t = parent.predicate("fhir:"+parentType+'.'+name); 5626 } 5627 composeBackboneElement(t, "detail", name, element, index); 5628 if (element.hasSequenceElement()) 5629 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 5630 if (element.hasType()) 5631 composeCoding(t, "ExplanationOfBenefit", "type", element.getType(), -1); 5632 if (element.hasService()) 5633 composeCoding(t, "ExplanationOfBenefit", "service", element.getService(), -1); 5634 for (int i = 0; i < element.getProgramCode().size(); i++) 5635 composeCoding(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 5636 if (element.hasQuantity()) 5637 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 5638 if (element.hasUnitPrice()) 5639 composeQuantity(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 5640 if (element.hasFactorElement()) 5641 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 5642 if (element.hasPointsElement()) 5643 composeDecimal(t, "ExplanationOfBenefit", "points", element.getPointsElement(), -1); 5644 if (element.hasNet()) 5645 composeQuantity(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 5646 for (int i = 0; i < element.getUdi().size(); i++) 5647 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 5648 for (int i = 0; i < element.getAdjudication().size(); i++) 5649 composeExplanationOfBenefitDetailAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 5650 for (int i = 0; i < element.getSubDetail().size(); i++) 5651 composeExplanationOfBenefitSubDetailComponent(t, "ExplanationOfBenefit", "subDetail", element.getSubDetail().get(i), i); 5652 } 5653 5654 protected void composeExplanationOfBenefitDetailAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.DetailAdjudicationComponent element, int index) { 5655 if (element == null) 5656 return; 5657 Complex t; 5658 if (Utilities.noString(parentType)) 5659 t = parent; 5660 else { 5661 t = parent.predicate("fhir:"+parentType+'.'+name); 5662 } 5663 composeBackboneElement(t, "adjudication", name, element, index); 5664 if (element.hasCategory()) 5665 composeCoding(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 5666 if (element.hasReason()) 5667 composeCoding(t, "ExplanationOfBenefit", "reason", element.getReason(), -1); 5668 if (element.hasAmount()) 5669 composeQuantity(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1); 5670 if (element.hasValueElement()) 5671 composeDecimal(t, "ExplanationOfBenefit", "value", element.getValueElement(), -1); 5672 } 5673 5674 protected void composeExplanationOfBenefitSubDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SubDetailComponent element, int index) { 5675 if (element == null) 5676 return; 5677 Complex t; 5678 if (Utilities.noString(parentType)) 5679 t = parent; 5680 else { 5681 t = parent.predicate("fhir:"+parentType+'.'+name); 5682 } 5683 composeBackboneElement(t, "subDetail", name, element, index); 5684 if (element.hasSequenceElement()) 5685 composePositiveInt(t, "ExplanationOfBenefit", "sequence", element.getSequenceElement(), -1); 5686 if (element.hasType()) 5687 composeCoding(t, "ExplanationOfBenefit", "type", element.getType(), -1); 5688 if (element.hasService()) 5689 composeCoding(t, "ExplanationOfBenefit", "service", element.getService(), -1); 5690 for (int i = 0; i < element.getProgramCode().size(); i++) 5691 composeCoding(t, "ExplanationOfBenefit", "programCode", element.getProgramCode().get(i), i); 5692 if (element.hasQuantity()) 5693 composeQuantity(t, "ExplanationOfBenefit", "quantity", element.getQuantity(), -1); 5694 if (element.hasUnitPrice()) 5695 composeQuantity(t, "ExplanationOfBenefit", "unitPrice", element.getUnitPrice(), -1); 5696 if (element.hasFactorElement()) 5697 composeDecimal(t, "ExplanationOfBenefit", "factor", element.getFactorElement(), -1); 5698 if (element.hasPointsElement()) 5699 composeDecimal(t, "ExplanationOfBenefit", "points", element.getPointsElement(), -1); 5700 if (element.hasNet()) 5701 composeQuantity(t, "ExplanationOfBenefit", "net", element.getNet(), -1); 5702 for (int i = 0; i < element.getUdi().size(); i++) 5703 composeReference(t, "ExplanationOfBenefit", "udi", element.getUdi().get(i), i); 5704 for (int i = 0; i < element.getAdjudication().size(); i++) 5705 composeExplanationOfBenefitSubDetailAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 5706 } 5707 5708 protected void composeExplanationOfBenefitSubDetailAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.SubDetailAdjudicationComponent element, int index) { 5709 if (element == null) 5710 return; 5711 Complex t; 5712 if (Utilities.noString(parentType)) 5713 t = parent; 5714 else { 5715 t = parent.predicate("fhir:"+parentType+'.'+name); 5716 } 5717 composeBackboneElement(t, "adjudication", name, element, index); 5718 if (element.hasCategory()) 5719 composeCoding(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 5720 if (element.hasReason()) 5721 composeCoding(t, "ExplanationOfBenefit", "reason", element.getReason(), -1); 5722 if (element.hasAmount()) 5723 composeQuantity(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1); 5724 if (element.hasValueElement()) 5725 composeDecimal(t, "ExplanationOfBenefit", "value", element.getValueElement(), -1); 5726 } 5727 5728 protected void composeExplanationOfBenefitProsthesisComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.ProsthesisComponent element, int index) { 5729 if (element == null) 5730 return; 5731 Complex t; 5732 if (Utilities.noString(parentType)) 5733 t = parent; 5734 else { 5735 t = parent.predicate("fhir:"+parentType+'.'+name); 5736 } 5737 composeBackboneElement(t, "prosthesis", name, element, index); 5738 if (element.hasInitialElement()) 5739 composeBoolean(t, "ExplanationOfBenefit", "initial", element.getInitialElement(), -1); 5740 if (element.hasPriorDateElement()) 5741 composeDate(t, "ExplanationOfBenefit", "priorDate", element.getPriorDateElement(), -1); 5742 if (element.hasPriorMaterial()) 5743 composeCoding(t, "ExplanationOfBenefit", "priorMaterial", element.getPriorMaterial(), -1); 5744 } 5745 5746 protected void composeExplanationOfBenefitAddedItemComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemComponent element, int index) { 5747 if (element == null) 5748 return; 5749 Complex t; 5750 if (Utilities.noString(parentType)) 5751 t = parent; 5752 else { 5753 t = parent.predicate("fhir:"+parentType+'.'+name); 5754 } 5755 composeBackboneElement(t, "addItem", name, element, index); 5756 for (int i = 0; i < element.getSequenceLinkId().size(); i++) 5757 composePositiveInt(t, "ExplanationOfBenefit", "sequenceLinkId", element.getSequenceLinkId().get(i), i); 5758 if (element.hasService()) 5759 composeCoding(t, "ExplanationOfBenefit", "service", element.getService(), -1); 5760 if (element.hasFee()) 5761 composeQuantity(t, "ExplanationOfBenefit", "fee", element.getFee(), -1); 5762 for (int i = 0; i < element.getNoteNumberLinkId().size(); i++) 5763 composePositiveInt(t, "ExplanationOfBenefit", "noteNumberLinkId", element.getNoteNumberLinkId().get(i), i); 5764 for (int i = 0; i < element.getAdjudication().size(); i++) 5765 composeExplanationOfBenefitAddedItemAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 5766 for (int i = 0; i < element.getDetail().size(); i++) 5767 composeExplanationOfBenefitAddedItemsDetailComponent(t, "ExplanationOfBenefit", "detail", element.getDetail().get(i), i); 5768 } 5769 5770 protected void composeExplanationOfBenefitAddedItemAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemAdjudicationComponent element, int index) { 5771 if (element == null) 5772 return; 5773 Complex t; 5774 if (Utilities.noString(parentType)) 5775 t = parent; 5776 else { 5777 t = parent.predicate("fhir:"+parentType+'.'+name); 5778 } 5779 composeBackboneElement(t, "adjudication", name, element, index); 5780 if (element.hasCategory()) 5781 composeCoding(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 5782 if (element.hasReason()) 5783 composeCoding(t, "ExplanationOfBenefit", "reason", element.getReason(), -1); 5784 if (element.hasAmount()) 5785 composeQuantity(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1); 5786 if (element.hasValueElement()) 5787 composeDecimal(t, "ExplanationOfBenefit", "value", element.getValueElement(), -1); 5788 } 5789 5790 protected void composeExplanationOfBenefitAddedItemsDetailComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemsDetailComponent element, int index) { 5791 if (element == null) 5792 return; 5793 Complex t; 5794 if (Utilities.noString(parentType)) 5795 t = parent; 5796 else { 5797 t = parent.predicate("fhir:"+parentType+'.'+name); 5798 } 5799 composeBackboneElement(t, "detail", name, element, index); 5800 if (element.hasService()) 5801 composeCoding(t, "ExplanationOfBenefit", "service", element.getService(), -1); 5802 if (element.hasFee()) 5803 composeQuantity(t, "ExplanationOfBenefit", "fee", element.getFee(), -1); 5804 for (int i = 0; i < element.getAdjudication().size(); i++) 5805 composeExplanationOfBenefitAddedItemDetailAdjudicationComponent(t, "ExplanationOfBenefit", "adjudication", element.getAdjudication().get(i), i); 5806 } 5807 5808 protected void composeExplanationOfBenefitAddedItemDetailAdjudicationComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.AddedItemDetailAdjudicationComponent element, int index) { 5809 if (element == null) 5810 return; 5811 Complex t; 5812 if (Utilities.noString(parentType)) 5813 t = parent; 5814 else { 5815 t = parent.predicate("fhir:"+parentType+'.'+name); 5816 } 5817 composeBackboneElement(t, "adjudication", name, element, index); 5818 if (element.hasCategory()) 5819 composeCoding(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 5820 if (element.hasReason()) 5821 composeCoding(t, "ExplanationOfBenefit", "reason", element.getReason(), -1); 5822 if (element.hasAmount()) 5823 composeQuantity(t, "ExplanationOfBenefit", "amount", element.getAmount(), -1); 5824 if (element.hasValueElement()) 5825 composeDecimal(t, "ExplanationOfBenefit", "value", element.getValueElement(), -1); 5826 } 5827 5828 protected void composeExplanationOfBenefitMissingTeethComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.MissingTeethComponent element, int index) { 5829 if (element == null) 5830 return; 5831 Complex t; 5832 if (Utilities.noString(parentType)) 5833 t = parent; 5834 else { 5835 t = parent.predicate("fhir:"+parentType+'.'+name); 5836 } 5837 composeBackboneElement(t, "missingTeeth", name, element, index); 5838 if (element.hasTooth()) 5839 composeCoding(t, "ExplanationOfBenefit", "tooth", element.getTooth(), -1); 5840 if (element.hasReason()) 5841 composeCoding(t, "ExplanationOfBenefit", "reason", element.getReason(), -1); 5842 if (element.hasExtractionDateElement()) 5843 composeDate(t, "ExplanationOfBenefit", "extractionDate", element.getExtractionDateElement(), -1); 5844 } 5845 5846 protected void composeExplanationOfBenefitNotesComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.NotesComponent element, int index) { 5847 if (element == null) 5848 return; 5849 Complex t; 5850 if (Utilities.noString(parentType)) 5851 t = parent; 5852 else { 5853 t = parent.predicate("fhir:"+parentType+'.'+name); 5854 } 5855 composeBackboneElement(t, "note", name, element, index); 5856 if (element.hasNumberElement()) 5857 composePositiveInt(t, "ExplanationOfBenefit", "number", element.getNumberElement(), -1); 5858 if (element.hasType()) 5859 composeCoding(t, "ExplanationOfBenefit", "type", element.getType(), -1); 5860 if (element.hasTextElement()) 5861 composeString(t, "ExplanationOfBenefit", "text", element.getTextElement(), -1); 5862 } 5863 5864 protected void composeExplanationOfBenefitBenefitBalanceComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitBalanceComponent element, int index) { 5865 if (element == null) 5866 return; 5867 Complex t; 5868 if (Utilities.noString(parentType)) 5869 t = parent; 5870 else { 5871 t = parent.predicate("fhir:"+parentType+'.'+name); 5872 } 5873 composeBackboneElement(t, "benefitBalance", name, element, index); 5874 if (element.hasCategory()) 5875 composeCoding(t, "ExplanationOfBenefit", "category", element.getCategory(), -1); 5876 if (element.hasSubCategory()) 5877 composeCoding(t, "ExplanationOfBenefit", "subCategory", element.getSubCategory(), -1); 5878 if (element.hasNetwork()) 5879 composeCoding(t, "ExplanationOfBenefit", "network", element.getNetwork(), -1); 5880 if (element.hasUnit()) 5881 composeCoding(t, "ExplanationOfBenefit", "unit", element.getUnit(), -1); 5882 if (element.hasTerm()) 5883 composeCoding(t, "ExplanationOfBenefit", "term", element.getTerm(), -1); 5884 for (int i = 0; i < element.getFinancial().size(); i++) 5885 composeExplanationOfBenefitBenefitComponent(t, "ExplanationOfBenefit", "financial", element.getFinancial().get(i), i); 5886 } 5887 5888 protected void composeExplanationOfBenefitBenefitComponent(Complex parent, String parentType, String name, ExplanationOfBenefit.BenefitComponent element, int index) { 5889 if (element == null) 5890 return; 5891 Complex t; 5892 if (Utilities.noString(parentType)) 5893 t = parent; 5894 else { 5895 t = parent.predicate("fhir:"+parentType+'.'+name); 5896 } 5897 composeBackboneElement(t, "financial", name, element, index); 5898 if (element.hasType()) 5899 composeCoding(t, "ExplanationOfBenefit", "type", element.getType(), -1); 5900 if (element.hasBenefit()) 5901 composeType(t, "ExplanationOfBenefit", "benefit", element.getBenefit(), -1); 5902 if (element.hasBenefitUsed()) 5903 composeType(t, "ExplanationOfBenefit", "benefitUsed", element.getBenefitUsed(), -1); 5904 } 5905 5906 protected void composeFamilyMemberHistory(Complex parent, String parentType, String name, FamilyMemberHistory element, int index) { 5907 if (element == null) 5908 return; 5909 Complex t; 5910 if (Utilities.noString(parentType)) 5911 t = parent; 5912 else { 5913 t = parent.predicate("fhir:"+parentType+'.'+name); 5914 } 5915 composeDomainResource(t, "FamilyMemberHistory", name, element, index); 5916 for (int i = 0; i < element.getIdentifier().size(); i++) 5917 composeIdentifier(t, "FamilyMemberHistory", "identifier", element.getIdentifier().get(i), i); 5918 if (element.hasPatient()) 5919 composeReference(t, "FamilyMemberHistory", "patient", element.getPatient(), -1); 5920 if (element.hasDateElement()) 5921 composeDateTime(t, "FamilyMemberHistory", "date", element.getDateElement(), -1); 5922 if (element.hasStatusElement()) 5923 composeEnum(t, "FamilyMemberHistory", "status", element.getStatusElement(), -1); 5924 if (element.hasNameElement()) 5925 composeString(t, "FamilyMemberHistory", "name", element.getNameElement(), -1); 5926 if (element.hasRelationship()) 5927 composeCodeableConcept(t, "FamilyMemberHistory", "relationship", element.getRelationship(), -1); 5928 if (element.hasGenderElement()) 5929 composeEnum(t, "FamilyMemberHistory", "gender", element.getGenderElement(), -1); 5930 if (element.hasBorn()) 5931 composeType(t, "FamilyMemberHistory", "born", element.getBorn(), -1); 5932 if (element.hasAge()) 5933 composeType(t, "FamilyMemberHistory", "age", element.getAge(), -1); 5934 if (element.hasDeceased()) 5935 composeType(t, "FamilyMemberHistory", "deceased", element.getDeceased(), -1); 5936 if (element.hasNote()) 5937 composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote(), -1); 5938 for (int i = 0; i < element.getCondition().size(); i++) 5939 composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(t, "FamilyMemberHistory", "condition", element.getCondition().get(i), i); 5940 } 5941 5942 protected void composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(Complex parent, String parentType, String name, FamilyMemberHistory.FamilyMemberHistoryConditionComponent element, int index) { 5943 if (element == null) 5944 return; 5945 Complex t; 5946 if (Utilities.noString(parentType)) 5947 t = parent; 5948 else { 5949 t = parent.predicate("fhir:"+parentType+'.'+name); 5950 } 5951 composeBackboneElement(t, "condition", name, element, index); 5952 if (element.hasCode()) 5953 composeCodeableConcept(t, "FamilyMemberHistory", "code", element.getCode(), -1); 5954 if (element.hasOutcome()) 5955 composeCodeableConcept(t, "FamilyMemberHistory", "outcome", element.getOutcome(), -1); 5956 if (element.hasOnset()) 5957 composeType(t, "FamilyMemberHistory", "onset", element.getOnset(), -1); 5958 if (element.hasNote()) 5959 composeAnnotation(t, "FamilyMemberHistory", "note", element.getNote(), -1); 5960 } 5961 5962 protected void composeFlag(Complex parent, String parentType, String name, Flag element, int index) { 5963 if (element == null) 5964 return; 5965 Complex t; 5966 if (Utilities.noString(parentType)) 5967 t = parent; 5968 else { 5969 t = parent.predicate("fhir:"+parentType+'.'+name); 5970 } 5971 composeDomainResource(t, "Flag", name, element, index); 5972 for (int i = 0; i < element.getIdentifier().size(); i++) 5973 composeIdentifier(t, "Flag", "identifier", element.getIdentifier().get(i), i); 5974 if (element.hasCategory()) 5975 composeCodeableConcept(t, "Flag", "category", element.getCategory(), -1); 5976 if (element.hasStatusElement()) 5977 composeEnum(t, "Flag", "status", element.getStatusElement(), -1); 5978 if (element.hasPeriod()) 5979 composePeriod(t, "Flag", "period", element.getPeriod(), -1); 5980 if (element.hasSubject()) 5981 composeReference(t, "Flag", "subject", element.getSubject(), -1); 5982 if (element.hasEncounter()) 5983 composeReference(t, "Flag", "encounter", element.getEncounter(), -1); 5984 if (element.hasAuthor()) 5985 composeReference(t, "Flag", "author", element.getAuthor(), -1); 5986 if (element.hasCode()) 5987 composeCodeableConcept(t, "Flag", "code", element.getCode(), -1); 5988 } 5989 5990 protected void composeGoal(Complex parent, String parentType, String name, Goal element, int index) { 5991 if (element == null) 5992 return; 5993 Complex t; 5994 if (Utilities.noString(parentType)) 5995 t = parent; 5996 else { 5997 t = parent.predicate("fhir:"+parentType+'.'+name); 5998 } 5999 composeDomainResource(t, "Goal", name, element, index); 6000 for (int i = 0; i < element.getIdentifier().size(); i++) 6001 composeIdentifier(t, "Goal", "identifier", element.getIdentifier().get(i), i); 6002 if (element.hasSubject()) 6003 composeReference(t, "Goal", "subject", element.getSubject(), -1); 6004 if (element.hasStart()) 6005 composeType(t, "Goal", "start", element.getStart(), -1); 6006 if (element.hasTarget()) 6007 composeType(t, "Goal", "target", element.getTarget(), -1); 6008 for (int i = 0; i < element.getCategory().size(); i++) 6009 composeCodeableConcept(t, "Goal", "category", element.getCategory().get(i), i); 6010 if (element.hasDescriptionElement()) 6011 composeString(t, "Goal", "description", element.getDescriptionElement(), -1); 6012 if (element.hasStatusElement()) 6013 composeEnum(t, "Goal", "status", element.getStatusElement(), -1); 6014 if (element.hasStatusDateElement()) 6015 composeDate(t, "Goal", "statusDate", element.getStatusDateElement(), -1); 6016 if (element.hasStatusReason()) 6017 composeCodeableConcept(t, "Goal", "statusReason", element.getStatusReason(), -1); 6018 if (element.hasAuthor()) 6019 composeReference(t, "Goal", "author", element.getAuthor(), -1); 6020 if (element.hasPriority()) 6021 composeCodeableConcept(t, "Goal", "priority", element.getPriority(), -1); 6022 for (int i = 0; i < element.getAddresses().size(); i++) 6023 composeReference(t, "Goal", "addresses", element.getAddresses().get(i), i); 6024 for (int i = 0; i < element.getNote().size(); i++) 6025 composeAnnotation(t, "Goal", "note", element.getNote().get(i), i); 6026 for (int i = 0; i < element.getOutcome().size(); i++) 6027 composeGoalGoalOutcomeComponent(t, "Goal", "outcome", element.getOutcome().get(i), i); 6028 } 6029 6030 protected void composeGoalGoalOutcomeComponent(Complex parent, String parentType, String name, Goal.GoalOutcomeComponent element, int index) { 6031 if (element == null) 6032 return; 6033 Complex t; 6034 if (Utilities.noString(parentType)) 6035 t = parent; 6036 else { 6037 t = parent.predicate("fhir:"+parentType+'.'+name); 6038 } 6039 composeBackboneElement(t, "outcome", name, element, index); 6040 if (element.hasResult()) 6041 composeType(t, "Goal", "result", element.getResult(), -1); 6042 } 6043 6044 protected void composeGroup(Complex parent, String parentType, String name, Group element, int index) { 6045 if (element == null) 6046 return; 6047 Complex t; 6048 if (Utilities.noString(parentType)) 6049 t = parent; 6050 else { 6051 t = parent.predicate("fhir:"+parentType+'.'+name); 6052 } 6053 composeDomainResource(t, "Group", name, element, index); 6054 for (int i = 0; i < element.getIdentifier().size(); i++) 6055 composeIdentifier(t, "Group", "identifier", element.getIdentifier().get(i), i); 6056 if (element.hasTypeElement()) 6057 composeEnum(t, "Group", "type", element.getTypeElement(), -1); 6058 if (element.hasActualElement()) 6059 composeBoolean(t, "Group", "actual", element.getActualElement(), -1); 6060 if (element.hasActiveElement()) 6061 composeBoolean(t, "Group", "active", element.getActiveElement(), -1); 6062 if (element.hasCode()) 6063 composeCodeableConcept(t, "Group", "code", element.getCode(), -1); 6064 if (element.hasNameElement()) 6065 composeString(t, "Group", "name", element.getNameElement(), -1); 6066 if (element.hasQuantityElement()) 6067 composeUnsignedInt(t, "Group", "quantity", element.getQuantityElement(), -1); 6068 for (int i = 0; i < element.getCharacteristic().size(); i++) 6069 composeGroupGroupCharacteristicComponent(t, "Group", "characteristic", element.getCharacteristic().get(i), i); 6070 for (int i = 0; i < element.getMember().size(); i++) 6071 composeGroupGroupMemberComponent(t, "Group", "member", element.getMember().get(i), i); 6072 } 6073 6074 protected void composeGroupGroupCharacteristicComponent(Complex parent, String parentType, String name, Group.GroupCharacteristicComponent element, int index) { 6075 if (element == null) 6076 return; 6077 Complex t; 6078 if (Utilities.noString(parentType)) 6079 t = parent; 6080 else { 6081 t = parent.predicate("fhir:"+parentType+'.'+name); 6082 } 6083 composeBackboneElement(t, "characteristic", name, element, index); 6084 if (element.hasCode()) 6085 composeCodeableConcept(t, "Group", "code", element.getCode(), -1); 6086 if (element.hasValue()) 6087 composeType(t, "Group", "value", element.getValue(), -1); 6088 if (element.hasExcludeElement()) 6089 composeBoolean(t, "Group", "exclude", element.getExcludeElement(), -1); 6090 if (element.hasPeriod()) 6091 composePeriod(t, "Group", "period", element.getPeriod(), -1); 6092 } 6093 6094 protected void composeGroupGroupMemberComponent(Complex parent, String parentType, String name, Group.GroupMemberComponent element, int index) { 6095 if (element == null) 6096 return; 6097 Complex t; 6098 if (Utilities.noString(parentType)) 6099 t = parent; 6100 else { 6101 t = parent.predicate("fhir:"+parentType+'.'+name); 6102 } 6103 composeBackboneElement(t, "member", name, element, index); 6104 if (element.hasEntity()) 6105 composeReference(t, "Group", "entity", element.getEntity(), -1); 6106 if (element.hasPeriod()) 6107 composePeriod(t, "Group", "period", element.getPeriod(), -1); 6108 if (element.hasInactiveElement()) 6109 composeBoolean(t, "Group", "inactive", element.getInactiveElement(), -1); 6110 } 6111 6112 protected void composeGuidanceResponse(Complex parent, String parentType, String name, GuidanceResponse element, int index) { 6113 if (element == null) 6114 return; 6115 Complex t; 6116 if (Utilities.noString(parentType)) 6117 t = parent; 6118 else { 6119 t = parent.predicate("fhir:"+parentType+'.'+name); 6120 } 6121 composeDomainResource(t, "GuidanceResponse", name, element, index); 6122 if (element.hasRequestIdElement()) 6123 composeString(t, "GuidanceResponse", "requestId", element.getRequestIdElement(), -1); 6124 if (element.hasModule()) 6125 composeReference(t, "GuidanceResponse", "module", element.getModule(), -1); 6126 if (element.hasStatusElement()) 6127 composeEnum(t, "GuidanceResponse", "status", element.getStatusElement(), -1); 6128 for (int i = 0; i < element.getEvaluationMessage().size(); i++) 6129 composeReference(t, "GuidanceResponse", "evaluationMessage", element.getEvaluationMessage().get(i), i); 6130 if (element.hasOutputParameters()) 6131 composeReference(t, "GuidanceResponse", "outputParameters", element.getOutputParameters(), -1); 6132 for (int i = 0; i < element.getAction().size(); i++) 6133 composeGuidanceResponseGuidanceResponseActionComponent(t, "GuidanceResponse", "action", element.getAction().get(i), i); 6134 for (int i = 0; i < element.getDataRequirement().size(); i++) 6135 composeDataRequirement(t, "GuidanceResponse", "dataRequirement", element.getDataRequirement().get(i), i); 6136 } 6137 6138 protected void composeGuidanceResponseGuidanceResponseActionComponent(Complex parent, String parentType, String name, GuidanceResponse.GuidanceResponseActionComponent element, int index) { 6139 if (element == null) 6140 return; 6141 Complex t; 6142 if (Utilities.noString(parentType)) 6143 t = parent; 6144 else { 6145 t = parent.predicate("fhir:"+parentType+'.'+name); 6146 } 6147 composeBackboneElement(t, "action", name, element, index); 6148 if (element.hasActionIdentifier()) 6149 composeIdentifier(t, "GuidanceResponse", "actionIdentifier", element.getActionIdentifier(), -1); 6150 if (element.hasLabelElement()) 6151 composeString(t, "GuidanceResponse", "label", element.getLabelElement(), -1); 6152 if (element.hasTitleElement()) 6153 composeString(t, "GuidanceResponse", "title", element.getTitleElement(), -1); 6154 if (element.hasDescriptionElement()) 6155 composeString(t, "GuidanceResponse", "description", element.getDescriptionElement(), -1); 6156 if (element.hasTextEquivalentElement()) 6157 composeString(t, "GuidanceResponse", "textEquivalent", element.getTextEquivalentElement(), -1); 6158 for (int i = 0; i < element.getConcept().size(); i++) 6159 composeCodeableConcept(t, "GuidanceResponse", "concept", element.getConcept().get(i), i); 6160 for (int i = 0; i < element.getSupportingEvidence().size(); i++) 6161 composeAttachment(t, "GuidanceResponse", "supportingEvidence", element.getSupportingEvidence().get(i), i); 6162 if (element.hasRelatedAction()) 6163 composeGuidanceResponseGuidanceResponseActionRelatedActionComponent(t, "GuidanceResponse", "relatedAction", element.getRelatedAction(), -1); 6164 for (int i = 0; i < element.getDocumentation().size(); i++) 6165 composeAttachment(t, "GuidanceResponse", "documentation", element.getDocumentation().get(i), i); 6166 for (int i = 0; i < element.getParticipant().size(); i++) 6167 composeReference(t, "GuidanceResponse", "participant", element.getParticipant().get(i), i); 6168 if (element.hasTypeElement()) 6169 composeCode(t, "GuidanceResponse", "type", element.getTypeElement(), -1); 6170 for (int i = 0; i < element.getBehavior().size(); i++) 6171 composeGuidanceResponseGuidanceResponseActionBehaviorComponent(t, "GuidanceResponse", "behavior", element.getBehavior().get(i), i); 6172 if (element.hasResource()) 6173 composeReference(t, "GuidanceResponse", "resource", element.getResource(), -1); 6174 for (int i = 0; i < element.getAction().size(); i++) 6175 composeGuidanceResponseGuidanceResponseActionComponent(t, "GuidanceResponse", "action", element.getAction().get(i), i); 6176 } 6177 6178 protected void composeGuidanceResponseGuidanceResponseActionRelatedActionComponent(Complex parent, String parentType, String name, GuidanceResponse.GuidanceResponseActionRelatedActionComponent element, int index) { 6179 if (element == null) 6180 return; 6181 Complex t; 6182 if (Utilities.noString(parentType)) 6183 t = parent; 6184 else { 6185 t = parent.predicate("fhir:"+parentType+'.'+name); 6186 } 6187 composeBackboneElement(t, "relatedAction", name, element, index); 6188 if (element.hasActionIdentifier()) 6189 composeIdentifier(t, "GuidanceResponse", "actionIdentifier", element.getActionIdentifier(), -1); 6190 if (element.hasRelationshipElement()) 6191 composeCode(t, "GuidanceResponse", "relationship", element.getRelationshipElement(), -1); 6192 if (element.hasOffset()) 6193 composeType(t, "GuidanceResponse", "offset", element.getOffset(), -1); 6194 if (element.hasAnchorElement()) 6195 composeCode(t, "GuidanceResponse", "anchor", element.getAnchorElement(), -1); 6196 } 6197 6198 protected void composeGuidanceResponseGuidanceResponseActionBehaviorComponent(Complex parent, String parentType, String name, GuidanceResponse.GuidanceResponseActionBehaviorComponent element, int index) { 6199 if (element == null) 6200 return; 6201 Complex t; 6202 if (Utilities.noString(parentType)) 6203 t = parent; 6204 else { 6205 t = parent.predicate("fhir:"+parentType+'.'+name); 6206 } 6207 composeBackboneElement(t, "behavior", name, element, index); 6208 if (element.hasType()) 6209 composeCoding(t, "GuidanceResponse", "type", element.getType(), -1); 6210 if (element.hasValue()) 6211 composeCoding(t, "GuidanceResponse", "value", element.getValue(), -1); 6212 } 6213 6214 protected void composeHealthcareService(Complex parent, String parentType, String name, HealthcareService element, int index) { 6215 if (element == null) 6216 return; 6217 Complex t; 6218 if (Utilities.noString(parentType)) 6219 t = parent; 6220 else { 6221 t = parent.predicate("fhir:"+parentType+'.'+name); 6222 } 6223 composeDomainResource(t, "HealthcareService", name, element, index); 6224 for (int i = 0; i < element.getIdentifier().size(); i++) 6225 composeIdentifier(t, "HealthcareService", "identifier", element.getIdentifier().get(i), i); 6226 if (element.hasProvidedBy()) 6227 composeReference(t, "HealthcareService", "providedBy", element.getProvidedBy(), -1); 6228 if (element.hasServiceCategory()) 6229 composeCodeableConcept(t, "HealthcareService", "serviceCategory", element.getServiceCategory(), -1); 6230 for (int i = 0; i < element.getServiceType().size(); i++) 6231 composeCodeableConcept(t, "HealthcareService", "serviceType", element.getServiceType().get(i), i); 6232 for (int i = 0; i < element.getSpecialty().size(); i++) 6233 composeCodeableConcept(t, "HealthcareService", "specialty", element.getSpecialty().get(i), i); 6234 for (int i = 0; i < element.getLocation().size(); i++) 6235 composeReference(t, "HealthcareService", "location", element.getLocation().get(i), i); 6236 if (element.hasServiceNameElement()) 6237 composeString(t, "HealthcareService", "serviceName", element.getServiceNameElement(), -1); 6238 if (element.hasCommentElement()) 6239 composeString(t, "HealthcareService", "comment", element.getCommentElement(), -1); 6240 if (element.hasExtraDetailsElement()) 6241 composeString(t, "HealthcareService", "extraDetails", element.getExtraDetailsElement(), -1); 6242 if (element.hasPhoto()) 6243 composeAttachment(t, "HealthcareService", "photo", element.getPhoto(), -1); 6244 for (int i = 0; i < element.getTelecom().size(); i++) 6245 composeContactPoint(t, "HealthcareService", "telecom", element.getTelecom().get(i), i); 6246 for (int i = 0; i < element.getCoverageArea().size(); i++) 6247 composeReference(t, "HealthcareService", "coverageArea", element.getCoverageArea().get(i), i); 6248 for (int i = 0; i < element.getServiceProvisionCode().size(); i++) 6249 composeCodeableConcept(t, "HealthcareService", "serviceProvisionCode", element.getServiceProvisionCode().get(i), i); 6250 if (element.hasEligibility()) 6251 composeCodeableConcept(t, "HealthcareService", "eligibility", element.getEligibility(), -1); 6252 if (element.hasEligibilityNoteElement()) 6253 composeString(t, "HealthcareService", "eligibilityNote", element.getEligibilityNoteElement(), -1); 6254 for (int i = 0; i < element.getProgramName().size(); i++) 6255 composeString(t, "HealthcareService", "programName", element.getProgramName().get(i), i); 6256 for (int i = 0; i < element.getCharacteristic().size(); i++) 6257 composeCodeableConcept(t, "HealthcareService", "characteristic", element.getCharacteristic().get(i), i); 6258 for (int i = 0; i < element.getReferralMethod().size(); i++) 6259 composeCodeableConcept(t, "HealthcareService", "referralMethod", element.getReferralMethod().get(i), i); 6260 if (element.hasPublicKeyElement()) 6261 composeString(t, "HealthcareService", "publicKey", element.getPublicKeyElement(), -1); 6262 if (element.hasAppointmentRequiredElement()) 6263 composeBoolean(t, "HealthcareService", "appointmentRequired", element.getAppointmentRequiredElement(), -1); 6264 for (int i = 0; i < element.getAvailableTime().size(); i++) 6265 composeHealthcareServiceHealthcareServiceAvailableTimeComponent(t, "HealthcareService", "availableTime", element.getAvailableTime().get(i), i); 6266 for (int i = 0; i < element.getNotAvailable().size(); i++) 6267 composeHealthcareServiceHealthcareServiceNotAvailableComponent(t, "HealthcareService", "notAvailable", element.getNotAvailable().get(i), i); 6268 if (element.hasAvailabilityExceptionsElement()) 6269 composeString(t, "HealthcareService", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1); 6270 } 6271 6272 protected void composeHealthcareServiceHealthcareServiceAvailableTimeComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceAvailableTimeComponent element, int index) { 6273 if (element == null) 6274 return; 6275 Complex t; 6276 if (Utilities.noString(parentType)) 6277 t = parent; 6278 else { 6279 t = parent.predicate("fhir:"+parentType+'.'+name); 6280 } 6281 composeBackboneElement(t, "availableTime", name, element, index); 6282 for (int i = 0; i < element.getDaysOfWeek().size(); i++) 6283 composeEnum(t, "HealthcareService", "daysOfWeek", element.getDaysOfWeek().get(i), i); 6284 if (element.hasAllDayElement()) 6285 composeBoolean(t, "HealthcareService", "allDay", element.getAllDayElement(), -1); 6286 if (element.hasAvailableStartTimeElement()) 6287 composeTime(t, "HealthcareService", "availableStartTime", element.getAvailableStartTimeElement(), -1); 6288 if (element.hasAvailableEndTimeElement()) 6289 composeTime(t, "HealthcareService", "availableEndTime", element.getAvailableEndTimeElement(), -1); 6290 } 6291 6292 protected void composeHealthcareServiceHealthcareServiceNotAvailableComponent(Complex parent, String parentType, String name, HealthcareService.HealthcareServiceNotAvailableComponent element, int index) { 6293 if (element == null) 6294 return; 6295 Complex t; 6296 if (Utilities.noString(parentType)) 6297 t = parent; 6298 else { 6299 t = parent.predicate("fhir:"+parentType+'.'+name); 6300 } 6301 composeBackboneElement(t, "notAvailable", name, element, index); 6302 if (element.hasDescriptionElement()) 6303 composeString(t, "HealthcareService", "description", element.getDescriptionElement(), -1); 6304 if (element.hasDuring()) 6305 composePeriod(t, "HealthcareService", "during", element.getDuring(), -1); 6306 } 6307 6308 protected void composeImagingExcerpt(Complex parent, String parentType, String name, ImagingExcerpt element, int index) { 6309 if (element == null) 6310 return; 6311 Complex t; 6312 if (Utilities.noString(parentType)) 6313 t = parent; 6314 else { 6315 t = parent.predicate("fhir:"+parentType+'.'+name); 6316 } 6317 composeDomainResource(t, "ImagingExcerpt", name, element, index); 6318 if (element.hasUidElement()) 6319 composeOid(t, "ImagingExcerpt", "uid", element.getUidElement(), -1); 6320 if (element.hasPatient()) 6321 composeReference(t, "ImagingExcerpt", "patient", element.getPatient(), -1); 6322 if (element.hasAuthoringTimeElement()) 6323 composeDateTime(t, "ImagingExcerpt", "authoringTime", element.getAuthoringTimeElement(), -1); 6324 if (element.hasAuthor()) 6325 composeReference(t, "ImagingExcerpt", "author", element.getAuthor(), -1); 6326 if (element.hasTitle()) 6327 composeCodeableConcept(t, "ImagingExcerpt", "title", element.getTitle(), -1); 6328 if (element.hasDescriptionElement()) 6329 composeString(t, "ImagingExcerpt", "description", element.getDescriptionElement(), -1); 6330 for (int i = 0; i < element.getStudy().size(); i++) 6331 composeImagingExcerptStudyComponent(t, "ImagingExcerpt", "study", element.getStudy().get(i), i); 6332 } 6333 6334 protected void composeImagingExcerptStudyComponent(Complex parent, String parentType, String name, ImagingExcerpt.StudyComponent element, int index) { 6335 if (element == null) 6336 return; 6337 Complex t; 6338 if (Utilities.noString(parentType)) 6339 t = parent; 6340 else { 6341 t = parent.predicate("fhir:"+parentType+'.'+name); 6342 } 6343 composeBackboneElement(t, "study", name, element, index); 6344 if (element.hasUidElement()) 6345 composeOid(t, "ImagingExcerpt", "uid", element.getUidElement(), -1); 6346 if (element.hasImagingStudy()) 6347 composeReference(t, "ImagingExcerpt", "imagingStudy", element.getImagingStudy(), -1); 6348 for (int i = 0; i < element.getDicom().size(); i++) 6349 composeImagingExcerptStudyDicomComponent(t, "ImagingExcerpt", "dicom", element.getDicom().get(i), i); 6350 for (int i = 0; i < element.getViewable().size(); i++) 6351 composeImagingExcerptStudyViewableComponent(t, "ImagingExcerpt", "viewable", element.getViewable().get(i), i); 6352 for (int i = 0; i < element.getSeries().size(); i++) 6353 composeImagingExcerptSeriesComponent(t, "ImagingExcerpt", "series", element.getSeries().get(i), i); 6354 } 6355 6356 protected void composeImagingExcerptStudyDicomComponent(Complex parent, String parentType, String name, ImagingExcerpt.StudyDicomComponent element, int index) { 6357 if (element == null) 6358 return; 6359 Complex t; 6360 if (Utilities.noString(parentType)) 6361 t = parent; 6362 else { 6363 t = parent.predicate("fhir:"+parentType+'.'+name); 6364 } 6365 composeBackboneElement(t, "dicom", name, element, index); 6366 if (element.hasTypeElement()) 6367 composeEnum(t, "ImagingExcerpt", "type", element.getTypeElement(), -1); 6368 if (element.hasUrlElement()) 6369 composeUri(t, "ImagingExcerpt", "url", element.getUrlElement(), -1); 6370 } 6371 6372 protected void composeImagingExcerptStudyViewableComponent(Complex parent, String parentType, String name, ImagingExcerpt.StudyViewableComponent element, int index) { 6373 if (element == null) 6374 return; 6375 Complex t; 6376 if (Utilities.noString(parentType)) 6377 t = parent; 6378 else { 6379 t = parent.predicate("fhir:"+parentType+'.'+name); 6380 } 6381 composeBackboneElement(t, "viewable", name, element, index); 6382 if (element.hasContentTypeElement()) 6383 composeCode(t, "ImagingExcerpt", "contentType", element.getContentTypeElement(), -1); 6384 if (element.hasHeightElement()) 6385 composePositiveInt(t, "ImagingExcerpt", "height", element.getHeightElement(), -1); 6386 if (element.hasWidthElement()) 6387 composePositiveInt(t, "ImagingExcerpt", "width", element.getWidthElement(), -1); 6388 if (element.hasFramesElement()) 6389 composePositiveInt(t, "ImagingExcerpt", "frames", element.getFramesElement(), -1); 6390 if (element.hasDurationElement()) 6391 composeUnsignedInt(t, "ImagingExcerpt", "duration", element.getDurationElement(), -1); 6392 if (element.hasSizeElement()) 6393 composeUnsignedInt(t, "ImagingExcerpt", "size", element.getSizeElement(), -1); 6394 if (element.hasTitleElement()) 6395 composeString(t, "ImagingExcerpt", "title", element.getTitleElement(), -1); 6396 if (element.hasUrlElement()) 6397 composeUri(t, "ImagingExcerpt", "url", element.getUrlElement(), -1); 6398 } 6399 6400 protected void composeImagingExcerptSeriesComponent(Complex parent, String parentType, String name, ImagingExcerpt.SeriesComponent element, int index) { 6401 if (element == null) 6402 return; 6403 Complex t; 6404 if (Utilities.noString(parentType)) 6405 t = parent; 6406 else { 6407 t = parent.predicate("fhir:"+parentType+'.'+name); 6408 } 6409 composeBackboneElement(t, "series", name, element, index); 6410 if (element.hasUidElement()) 6411 composeOid(t, "ImagingExcerpt", "uid", element.getUidElement(), -1); 6412 for (int i = 0; i < element.getDicom().size(); i++) 6413 composeImagingExcerptSeriesDicomComponent(t, "ImagingExcerpt", "dicom", element.getDicom().get(i), i); 6414 for (int i = 0; i < element.getInstance().size(); i++) 6415 composeImagingExcerptInstanceComponent(t, "ImagingExcerpt", "instance", element.getInstance().get(i), i); 6416 } 6417 6418 protected void composeImagingExcerptSeriesDicomComponent(Complex parent, String parentType, String name, ImagingExcerpt.SeriesDicomComponent element, int index) { 6419 if (element == null) 6420 return; 6421 Complex t; 6422 if (Utilities.noString(parentType)) 6423 t = parent; 6424 else { 6425 t = parent.predicate("fhir:"+parentType+'.'+name); 6426 } 6427 composeBackboneElement(t, "dicom", name, element, index); 6428 if (element.hasTypeElement()) 6429 composeEnum(t, "ImagingExcerpt", "type", element.getTypeElement(), -1); 6430 if (element.hasUrlElement()) 6431 composeUri(t, "ImagingExcerpt", "url", element.getUrlElement(), -1); 6432 } 6433 6434 protected void composeImagingExcerptInstanceComponent(Complex parent, String parentType, String name, ImagingExcerpt.InstanceComponent element, int index) { 6435 if (element == null) 6436 return; 6437 Complex t; 6438 if (Utilities.noString(parentType)) 6439 t = parent; 6440 else { 6441 t = parent.predicate("fhir:"+parentType+'.'+name); 6442 } 6443 composeBackboneElement(t, "instance", name, element, index); 6444 if (element.hasSopClassElement()) 6445 composeOid(t, "ImagingExcerpt", "sopClass", element.getSopClassElement(), -1); 6446 if (element.hasUidElement()) 6447 composeOid(t, "ImagingExcerpt", "uid", element.getUidElement(), -1); 6448 for (int i = 0; i < element.getDicom().size(); i++) 6449 composeImagingExcerptInstanceDicomComponent(t, "ImagingExcerpt", "dicom", element.getDicom().get(i), i); 6450 for (int i = 0; i < element.getFrameNumbers().size(); i++) 6451 composeUnsignedInt(t, "ImagingExcerpt", "frameNumbers", element.getFrameNumbers().get(i), i); 6452 } 6453 6454 protected void composeImagingExcerptInstanceDicomComponent(Complex parent, String parentType, String name, ImagingExcerpt.InstanceDicomComponent element, int index) { 6455 if (element == null) 6456 return; 6457 Complex t; 6458 if (Utilities.noString(parentType)) 6459 t = parent; 6460 else { 6461 t = parent.predicate("fhir:"+parentType+'.'+name); 6462 } 6463 composeBackboneElement(t, "dicom", name, element, index); 6464 if (element.hasTypeElement()) 6465 composeEnum(t, "ImagingExcerpt", "type", element.getTypeElement(), -1); 6466 if (element.hasUrlElement()) 6467 composeUri(t, "ImagingExcerpt", "url", element.getUrlElement(), -1); 6468 } 6469 6470 protected void composeImagingObjectSelection(Complex parent, String parentType, String name, ImagingObjectSelection element, int index) { 6471 if (element == null) 6472 return; 6473 Complex t; 6474 if (Utilities.noString(parentType)) 6475 t = parent; 6476 else { 6477 t = parent.predicate("fhir:"+parentType+'.'+name); 6478 } 6479 composeDomainResource(t, "ImagingObjectSelection", name, element, index); 6480 if (element.hasUidElement()) 6481 composeOid(t, "ImagingObjectSelection", "uid", element.getUidElement(), -1); 6482 if (element.hasPatient()) 6483 composeReference(t, "ImagingObjectSelection", "patient", element.getPatient(), -1); 6484 if (element.hasAuthoringTimeElement()) 6485 composeDateTime(t, "ImagingObjectSelection", "authoringTime", element.getAuthoringTimeElement(), -1); 6486 if (element.hasAuthor()) 6487 composeReference(t, "ImagingObjectSelection", "author", element.getAuthor(), -1); 6488 if (element.hasTitle()) 6489 composeCodeableConcept(t, "ImagingObjectSelection", "title", element.getTitle(), -1); 6490 if (element.hasDescriptionElement()) 6491 composeString(t, "ImagingObjectSelection", "description", element.getDescriptionElement(), -1); 6492 for (int i = 0; i < element.getStudy().size(); i++) 6493 composeImagingObjectSelectionStudyComponent(t, "ImagingObjectSelection", "study", element.getStudy().get(i), i); 6494 } 6495 6496 protected void composeImagingObjectSelectionStudyComponent(Complex parent, String parentType, String name, ImagingObjectSelection.StudyComponent element, int index) { 6497 if (element == null) 6498 return; 6499 Complex t; 6500 if (Utilities.noString(parentType)) 6501 t = parent; 6502 else { 6503 t = parent.predicate("fhir:"+parentType+'.'+name); 6504 } 6505 composeBackboneElement(t, "study", name, element, index); 6506 if (element.hasUidElement()) 6507 composeOid(t, "ImagingObjectSelection", "uid", element.getUidElement(), -1); 6508 if (element.hasUrlElement()) 6509 composeUri(t, "ImagingObjectSelection", "url", element.getUrlElement(), -1); 6510 if (element.hasImagingStudy()) 6511 composeReference(t, "ImagingObjectSelection", "imagingStudy", element.getImagingStudy(), -1); 6512 for (int i = 0; i < element.getSeries().size(); i++) 6513 composeImagingObjectSelectionSeriesComponent(t, "ImagingObjectSelection", "series", element.getSeries().get(i), i); 6514 } 6515 6516 protected void composeImagingObjectSelectionSeriesComponent(Complex parent, String parentType, String name, ImagingObjectSelection.SeriesComponent element, int index) { 6517 if (element == null) 6518 return; 6519 Complex t; 6520 if (Utilities.noString(parentType)) 6521 t = parent; 6522 else { 6523 t = parent.predicate("fhir:"+parentType+'.'+name); 6524 } 6525 composeBackboneElement(t, "series", name, element, index); 6526 if (element.hasUidElement()) 6527 composeOid(t, "ImagingObjectSelection", "uid", element.getUidElement(), -1); 6528 if (element.hasUrlElement()) 6529 composeUri(t, "ImagingObjectSelection", "url", element.getUrlElement(), -1); 6530 for (int i = 0; i < element.getInstance().size(); i++) 6531 composeImagingObjectSelectionInstanceComponent(t, "ImagingObjectSelection", "instance", element.getInstance().get(i), i); 6532 } 6533 6534 protected void composeImagingObjectSelectionInstanceComponent(Complex parent, String parentType, String name, ImagingObjectSelection.InstanceComponent element, int index) { 6535 if (element == null) 6536 return; 6537 Complex t; 6538 if (Utilities.noString(parentType)) 6539 t = parent; 6540 else { 6541 t = parent.predicate("fhir:"+parentType+'.'+name); 6542 } 6543 composeBackboneElement(t, "instance", name, element, index); 6544 if (element.hasSopClassElement()) 6545 composeOid(t, "ImagingObjectSelection", "sopClass", element.getSopClassElement(), -1); 6546 if (element.hasUidElement()) 6547 composeOid(t, "ImagingObjectSelection", "uid", element.getUidElement(), -1); 6548 if (element.hasUrlElement()) 6549 composeUri(t, "ImagingObjectSelection", "url", element.getUrlElement(), -1); 6550 for (int i = 0; i < element.getFrame().size(); i++) 6551 composeImagingObjectSelectionFramesComponent(t, "ImagingObjectSelection", "frame", element.getFrame().get(i), i); 6552 } 6553 6554 protected void composeImagingObjectSelectionFramesComponent(Complex parent, String parentType, String name, ImagingObjectSelection.FramesComponent element, int index) { 6555 if (element == null) 6556 return; 6557 Complex t; 6558 if (Utilities.noString(parentType)) 6559 t = parent; 6560 else { 6561 t = parent.predicate("fhir:"+parentType+'.'+name); 6562 } 6563 composeBackboneElement(t, "frame", name, element, index); 6564 for (int i = 0; i < element.getNumber().size(); i++) 6565 composeUnsignedInt(t, "ImagingObjectSelection", "number", element.getNumber().get(i), i); 6566 if (element.hasUrlElement()) 6567 composeUri(t, "ImagingObjectSelection", "url", element.getUrlElement(), -1); 6568 } 6569 6570 protected void composeImagingStudy(Complex parent, String parentType, String name, ImagingStudy element, int index) { 6571 if (element == null) 6572 return; 6573 Complex t; 6574 if (Utilities.noString(parentType)) 6575 t = parent; 6576 else { 6577 t = parent.predicate("fhir:"+parentType+'.'+name); 6578 } 6579 composeDomainResource(t, "ImagingStudy", name, element, index); 6580 if (element.hasUidElement()) 6581 composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1); 6582 if (element.hasAccession()) 6583 composeIdentifier(t, "ImagingStudy", "accession", element.getAccession(), -1); 6584 for (int i = 0; i < element.getIdentifier().size(); i++) 6585 composeIdentifier(t, "ImagingStudy", "identifier", element.getIdentifier().get(i), i); 6586 if (element.hasAvailabilityElement()) 6587 composeEnum(t, "ImagingStudy", "availability", element.getAvailabilityElement(), -1); 6588 for (int i = 0; i < element.getModalityList().size(); i++) 6589 composeCoding(t, "ImagingStudy", "modalityList", element.getModalityList().get(i), i); 6590 if (element.hasPatient()) 6591 composeReference(t, "ImagingStudy", "patient", element.getPatient(), -1); 6592 if (element.hasStartedElement()) 6593 composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1); 6594 for (int i = 0; i < element.getOrder().size(); i++) 6595 composeReference(t, "ImagingStudy", "order", element.getOrder().get(i), i); 6596 if (element.hasReferrer()) 6597 composeReference(t, "ImagingStudy", "referrer", element.getReferrer(), -1); 6598 if (element.hasInterpreter()) 6599 composeReference(t, "ImagingStudy", "interpreter", element.getInterpreter(), -1); 6600 if (element.hasUrlElement()) 6601 composeUri(t, "ImagingStudy", "url", element.getUrlElement(), -1); 6602 if (element.hasNumberOfSeriesElement()) 6603 composeUnsignedInt(t, "ImagingStudy", "numberOfSeries", element.getNumberOfSeriesElement(), -1); 6604 if (element.hasNumberOfInstancesElement()) 6605 composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1); 6606 for (int i = 0; i < element.getProcedure().size(); i++) 6607 composeReference(t, "ImagingStudy", "procedure", element.getProcedure().get(i), i); 6608 if (element.hasDescriptionElement()) 6609 composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1); 6610 for (int i = 0; i < element.getSeries().size(); i++) 6611 composeImagingStudyImagingStudySeriesComponent(t, "ImagingStudy", "series", element.getSeries().get(i), i); 6612 } 6613 6614 protected void composeImagingStudyImagingStudySeriesComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesComponent element, int index) { 6615 if (element == null) 6616 return; 6617 Complex t; 6618 if (Utilities.noString(parentType)) 6619 t = parent; 6620 else { 6621 t = parent.predicate("fhir:"+parentType+'.'+name); 6622 } 6623 composeBackboneElement(t, "series", name, element, index); 6624 if (element.hasUidElement()) 6625 composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1); 6626 if (element.hasNumberElement()) 6627 composeUnsignedInt(t, "ImagingStudy", "number", element.getNumberElement(), -1); 6628 if (element.hasModality()) 6629 composeCoding(t, "ImagingStudy", "modality", element.getModality(), -1); 6630 if (element.hasDescriptionElement()) 6631 composeString(t, "ImagingStudy", "description", element.getDescriptionElement(), -1); 6632 if (element.hasNumberOfInstancesElement()) 6633 composeUnsignedInt(t, "ImagingStudy", "numberOfInstances", element.getNumberOfInstancesElement(), -1); 6634 if (element.hasAvailabilityElement()) 6635 composeEnum(t, "ImagingStudy", "availability", element.getAvailabilityElement(), -1); 6636 if (element.hasUrlElement()) 6637 composeUri(t, "ImagingStudy", "url", element.getUrlElement(), -1); 6638 if (element.hasBodySite()) 6639 composeCoding(t, "ImagingStudy", "bodySite", element.getBodySite(), -1); 6640 if (element.hasLaterality()) 6641 composeCoding(t, "ImagingStudy", "laterality", element.getLaterality(), -1); 6642 if (element.hasStartedElement()) 6643 composeDateTime(t, "ImagingStudy", "started", element.getStartedElement(), -1); 6644 for (int i = 0; i < element.getInstance().size(); i++) 6645 composeImagingStudyImagingStudySeriesInstanceComponent(t, "ImagingStudy", "instance", element.getInstance().get(i), i); 6646 } 6647 6648 protected void composeImagingStudyImagingStudySeriesInstanceComponent(Complex parent, String parentType, String name, ImagingStudy.ImagingStudySeriesInstanceComponent element, int index) { 6649 if (element == null) 6650 return; 6651 Complex t; 6652 if (Utilities.noString(parentType)) 6653 t = parent; 6654 else { 6655 t = parent.predicate("fhir:"+parentType+'.'+name); 6656 } 6657 composeBackboneElement(t, "instance", name, element, index); 6658 if (element.hasUidElement()) 6659 composeOid(t, "ImagingStudy", "uid", element.getUidElement(), -1); 6660 if (element.hasNumberElement()) 6661 composeUnsignedInt(t, "ImagingStudy", "number", element.getNumberElement(), -1); 6662 if (element.hasSopClassElement()) 6663 composeOid(t, "ImagingStudy", "sopClass", element.getSopClassElement(), -1); 6664 if (element.hasTypeElement()) 6665 composeString(t, "ImagingStudy", "type", element.getTypeElement(), -1); 6666 if (element.hasTitleElement()) 6667 composeString(t, "ImagingStudy", "title", element.getTitleElement(), -1); 6668 for (int i = 0; i < element.getContent().size(); i++) 6669 composeAttachment(t, "ImagingStudy", "content", element.getContent().get(i), i); 6670 } 6671 6672 protected void composeImmunization(Complex parent, String parentType, String name, Immunization element, int index) { 6673 if (element == null) 6674 return; 6675 Complex t; 6676 if (Utilities.noString(parentType)) 6677 t = parent; 6678 else { 6679 t = parent.predicate("fhir:"+parentType+'.'+name); 6680 } 6681 composeDomainResource(t, "Immunization", name, element, index); 6682 for (int i = 0; i < element.getIdentifier().size(); i++) 6683 composeIdentifier(t, "Immunization", "identifier", element.getIdentifier().get(i), i); 6684 if (element.hasStatusElement()) 6685 composeCode(t, "Immunization", "status", element.getStatusElement(), -1); 6686 if (element.hasDateElement()) 6687 composeDateTime(t, "Immunization", "date", element.getDateElement(), -1); 6688 if (element.hasVaccineCode()) 6689 composeCodeableConcept(t, "Immunization", "vaccineCode", element.getVaccineCode(), -1); 6690 if (element.hasPatient()) 6691 composeReference(t, "Immunization", "patient", element.getPatient(), -1); 6692 if (element.hasWasNotGivenElement()) 6693 composeBoolean(t, "Immunization", "wasNotGiven", element.getWasNotGivenElement(), -1); 6694 if (element.hasReportedElement()) 6695 composeBoolean(t, "Immunization", "reported", element.getReportedElement(), -1); 6696 if (element.hasPerformer()) 6697 composeReference(t, "Immunization", "performer", element.getPerformer(), -1); 6698 if (element.hasRequester()) 6699 composeReference(t, "Immunization", "requester", element.getRequester(), -1); 6700 if (element.hasEncounter()) 6701 composeReference(t, "Immunization", "encounter", element.getEncounter(), -1); 6702 if (element.hasManufacturer()) 6703 composeReference(t, "Immunization", "manufacturer", element.getManufacturer(), -1); 6704 if (element.hasLocation()) 6705 composeReference(t, "Immunization", "location", element.getLocation(), -1); 6706 if (element.hasLotNumberElement()) 6707 composeString(t, "Immunization", "lotNumber", element.getLotNumberElement(), -1); 6708 if (element.hasExpirationDateElement()) 6709 composeDate(t, "Immunization", "expirationDate", element.getExpirationDateElement(), -1); 6710 if (element.hasSite()) 6711 composeCodeableConcept(t, "Immunization", "site", element.getSite(), -1); 6712 if (element.hasRoute()) 6713 composeCodeableConcept(t, "Immunization", "route", element.getRoute(), -1); 6714 if (element.hasDoseQuantity()) 6715 composeQuantity(t, "Immunization", "doseQuantity", element.getDoseQuantity(), -1); 6716 for (int i = 0; i < element.getNote().size(); i++) 6717 composeAnnotation(t, "Immunization", "note", element.getNote().get(i), i); 6718 if (element.hasExplanation()) 6719 composeImmunizationImmunizationExplanationComponent(t, "Immunization", "explanation", element.getExplanation(), -1); 6720 for (int i = 0; i < element.getReaction().size(); i++) 6721 composeImmunizationImmunizationReactionComponent(t, "Immunization", "reaction", element.getReaction().get(i), i); 6722 for (int i = 0; i < element.getVaccinationProtocol().size(); i++) 6723 composeImmunizationImmunizationVaccinationProtocolComponent(t, "Immunization", "vaccinationProtocol", element.getVaccinationProtocol().get(i), i); 6724 } 6725 6726 protected void composeImmunizationImmunizationExplanationComponent(Complex parent, String parentType, String name, Immunization.ImmunizationExplanationComponent element, int index) { 6727 if (element == null) 6728 return; 6729 Complex t; 6730 if (Utilities.noString(parentType)) 6731 t = parent; 6732 else { 6733 t = parent.predicate("fhir:"+parentType+'.'+name); 6734 } 6735 composeBackboneElement(t, "explanation", name, element, index); 6736 for (int i = 0; i < element.getReason().size(); i++) 6737 composeCodeableConcept(t, "Immunization", "reason", element.getReason().get(i), i); 6738 for (int i = 0; i < element.getReasonNotGiven().size(); i++) 6739 composeCodeableConcept(t, "Immunization", "reasonNotGiven", element.getReasonNotGiven().get(i), i); 6740 } 6741 6742 protected void composeImmunizationImmunizationReactionComponent(Complex parent, String parentType, String name, Immunization.ImmunizationReactionComponent element, int index) { 6743 if (element == null) 6744 return; 6745 Complex t; 6746 if (Utilities.noString(parentType)) 6747 t = parent; 6748 else { 6749 t = parent.predicate("fhir:"+parentType+'.'+name); 6750 } 6751 composeBackboneElement(t, "reaction", name, element, index); 6752 if (element.hasDateElement()) 6753 composeDateTime(t, "Immunization", "date", element.getDateElement(), -1); 6754 if (element.hasDetail()) 6755 composeReference(t, "Immunization", "detail", element.getDetail(), -1); 6756 if (element.hasReportedElement()) 6757 composeBoolean(t, "Immunization", "reported", element.getReportedElement(), -1); 6758 } 6759 6760 protected void composeImmunizationImmunizationVaccinationProtocolComponent(Complex parent, String parentType, String name, Immunization.ImmunizationVaccinationProtocolComponent element, int index) { 6761 if (element == null) 6762 return; 6763 Complex t; 6764 if (Utilities.noString(parentType)) 6765 t = parent; 6766 else { 6767 t = parent.predicate("fhir:"+parentType+'.'+name); 6768 } 6769 composeBackboneElement(t, "vaccinationProtocol", name, element, index); 6770 if (element.hasDoseSequenceElement()) 6771 composePositiveInt(t, "Immunization", "doseSequence", element.getDoseSequenceElement(), -1); 6772 if (element.hasDescriptionElement()) 6773 composeString(t, "Immunization", "description", element.getDescriptionElement(), -1); 6774 if (element.hasAuthority()) 6775 composeReference(t, "Immunization", "authority", element.getAuthority(), -1); 6776 if (element.hasSeriesElement()) 6777 composeString(t, "Immunization", "series", element.getSeriesElement(), -1); 6778 if (element.hasSeriesDosesElement()) 6779 composePositiveInt(t, "Immunization", "seriesDoses", element.getSeriesDosesElement(), -1); 6780 for (int i = 0; i < element.getTargetDisease().size(); i++) 6781 composeCodeableConcept(t, "Immunization", "targetDisease", element.getTargetDisease().get(i), i); 6782 if (element.hasDoseStatus()) 6783 composeCodeableConcept(t, "Immunization", "doseStatus", element.getDoseStatus(), -1); 6784 if (element.hasDoseStatusReason()) 6785 composeCodeableConcept(t, "Immunization", "doseStatusReason", element.getDoseStatusReason(), -1); 6786 } 6787 6788 protected void composeImmunizationRecommendation(Complex parent, String parentType, String name, ImmunizationRecommendation element, int index) { 6789 if (element == null) 6790 return; 6791 Complex t; 6792 if (Utilities.noString(parentType)) 6793 t = parent; 6794 else { 6795 t = parent.predicate("fhir:"+parentType+'.'+name); 6796 } 6797 composeDomainResource(t, "ImmunizationRecommendation", name, element, index); 6798 for (int i = 0; i < element.getIdentifier().size(); i++) 6799 composeIdentifier(t, "ImmunizationRecommendation", "identifier", element.getIdentifier().get(i), i); 6800 if (element.hasPatient()) 6801 composeReference(t, "ImmunizationRecommendation", "patient", element.getPatient(), -1); 6802 for (int i = 0; i < element.getRecommendation().size(); i++) 6803 composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(t, "ImmunizationRecommendation", "recommendation", element.getRecommendation().get(i), i); 6804 } 6805 6806 protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent element, int index) { 6807 if (element == null) 6808 return; 6809 Complex t; 6810 if (Utilities.noString(parentType)) 6811 t = parent; 6812 else { 6813 t = parent.predicate("fhir:"+parentType+'.'+name); 6814 } 6815 composeBackboneElement(t, "recommendation", name, element, index); 6816 if (element.hasDateElement()) 6817 composeDateTime(t, "ImmunizationRecommendation", "date", element.getDateElement(), -1); 6818 if (element.hasVaccineCode()) 6819 composeCodeableConcept(t, "ImmunizationRecommendation", "vaccineCode", element.getVaccineCode(), -1); 6820 if (element.hasDoseNumberElement()) 6821 composePositiveInt(t, "ImmunizationRecommendation", "doseNumber", element.getDoseNumberElement(), -1); 6822 if (element.hasForecastStatus()) 6823 composeCodeableConcept(t, "ImmunizationRecommendation", "forecastStatus", element.getForecastStatus(), -1); 6824 for (int i = 0; i < element.getDateCriterion().size(); i++) 6825 composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(t, "ImmunizationRecommendation", "dateCriterion", element.getDateCriterion().get(i), i); 6826 if (element.hasProtocol()) 6827 composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(t, "ImmunizationRecommendation", "protocol", element.getProtocol(), -1); 6828 for (int i = 0; i < element.getSupportingImmunization().size(); i++) 6829 composeReference(t, "ImmunizationRecommendation", "supportingImmunization", element.getSupportingImmunization().get(i), i); 6830 for (int i = 0; i < element.getSupportingPatientInformation().size(); i++) 6831 composeReference(t, "ImmunizationRecommendation", "supportingPatientInformation", element.getSupportingPatientInformation().get(i), i); 6832 } 6833 6834 protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent element, int index) { 6835 if (element == null) 6836 return; 6837 Complex t; 6838 if (Utilities.noString(parentType)) 6839 t = parent; 6840 else { 6841 t = parent.predicate("fhir:"+parentType+'.'+name); 6842 } 6843 composeBackboneElement(t, "dateCriterion", name, element, index); 6844 if (element.hasCode()) 6845 composeCodeableConcept(t, "ImmunizationRecommendation", "code", element.getCode(), -1); 6846 if (element.hasValueElement()) 6847 composeDateTime(t, "ImmunizationRecommendation", "value", element.getValueElement(), -1); 6848 } 6849 6850 protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(Complex parent, String parentType, String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent element, int index) { 6851 if (element == null) 6852 return; 6853 Complex t; 6854 if (Utilities.noString(parentType)) 6855 t = parent; 6856 else { 6857 t = parent.predicate("fhir:"+parentType+'.'+name); 6858 } 6859 composeBackboneElement(t, "protocol", name, element, index); 6860 if (element.hasDoseSequenceElement()) 6861 composeInteger(t, "ImmunizationRecommendation", "doseSequence", element.getDoseSequenceElement(), -1); 6862 if (element.hasDescriptionElement()) 6863 composeString(t, "ImmunizationRecommendation", "description", element.getDescriptionElement(), -1); 6864 if (element.hasAuthority()) 6865 composeReference(t, "ImmunizationRecommendation", "authority", element.getAuthority(), -1); 6866 if (element.hasSeriesElement()) 6867 composeString(t, "ImmunizationRecommendation", "series", element.getSeriesElement(), -1); 6868 } 6869 6870 protected void composeImplementationGuide(Complex parent, String parentType, String name, ImplementationGuide element, int index) { 6871 if (element == null) 6872 return; 6873 Complex t; 6874 if (Utilities.noString(parentType)) 6875 t = parent; 6876 else { 6877 t = parent.predicate("fhir:"+parentType+'.'+name); 6878 } 6879 composeDomainResource(t, "ImplementationGuide", name, element, index); 6880 if (element.hasUrlElement()) 6881 composeUri(t, "ImplementationGuide", "url", element.getUrlElement(), -1); 6882 if (element.hasVersionElement()) 6883 composeString(t, "ImplementationGuide", "version", element.getVersionElement(), -1); 6884 if (element.hasNameElement()) 6885 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 6886 if (element.hasStatusElement()) 6887 composeEnum(t, "ImplementationGuide", "status", element.getStatusElement(), -1); 6888 if (element.hasExperimentalElement()) 6889 composeBoolean(t, "ImplementationGuide", "experimental", element.getExperimentalElement(), -1); 6890 if (element.hasPublisherElement()) 6891 composeString(t, "ImplementationGuide", "publisher", element.getPublisherElement(), -1); 6892 for (int i = 0; i < element.getContact().size(); i++) 6893 composeImplementationGuideImplementationGuideContactComponent(t, "ImplementationGuide", "contact", element.getContact().get(i), i); 6894 if (element.hasDateElement()) 6895 composeDateTime(t, "ImplementationGuide", "date", element.getDateElement(), -1); 6896 if (element.hasDescriptionElement()) 6897 composeString(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 6898 for (int i = 0; i < element.getUseContext().size(); i++) 6899 composeCodeableConcept(t, "ImplementationGuide", "useContext", element.getUseContext().get(i), i); 6900 if (element.hasCopyrightElement()) 6901 composeString(t, "ImplementationGuide", "copyright", element.getCopyrightElement(), -1); 6902 if (element.hasFhirVersionElement()) 6903 composeId(t, "ImplementationGuide", "fhirVersion", element.getFhirVersionElement(), -1); 6904 for (int i = 0; i < element.getDependency().size(); i++) 6905 composeImplementationGuideImplementationGuideDependencyComponent(t, "ImplementationGuide", "dependency", element.getDependency().get(i), i); 6906 for (int i = 0; i < element.getPackage().size(); i++) 6907 composeImplementationGuideImplementationGuidePackageComponent(t, "ImplementationGuide", "package", element.getPackage().get(i), i); 6908 for (int i = 0; i < element.getGlobal().size(); i++) 6909 composeImplementationGuideImplementationGuideGlobalComponent(t, "ImplementationGuide", "global", element.getGlobal().get(i), i); 6910 for (int i = 0; i < element.getBinary().size(); i++) 6911 composeUri(t, "ImplementationGuide", "binary", element.getBinary().get(i), i); 6912 if (element.hasPage()) 6913 composeImplementationGuideImplementationGuidePageComponent(t, "ImplementationGuide", "page", element.getPage(), -1); 6914 } 6915 6916 protected void composeImplementationGuideImplementationGuideContactComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideContactComponent element, int index) { 6917 if (element == null) 6918 return; 6919 Complex t; 6920 if (Utilities.noString(parentType)) 6921 t = parent; 6922 else { 6923 t = parent.predicate("fhir:"+parentType+'.'+name); 6924 } 6925 composeBackboneElement(t, "contact", name, element, index); 6926 if (element.hasNameElement()) 6927 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 6928 for (int i = 0; i < element.getTelecom().size(); i++) 6929 composeContactPoint(t, "ImplementationGuide", "telecom", element.getTelecom().get(i), i); 6930 } 6931 6932 protected void composeImplementationGuideImplementationGuideDependencyComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideDependencyComponent element, int index) { 6933 if (element == null) 6934 return; 6935 Complex t; 6936 if (Utilities.noString(parentType)) 6937 t = parent; 6938 else { 6939 t = parent.predicate("fhir:"+parentType+'.'+name); 6940 } 6941 composeBackboneElement(t, "dependency", name, element, index); 6942 if (element.hasTypeElement()) 6943 composeEnum(t, "ImplementationGuide", "type", element.getTypeElement(), -1); 6944 if (element.hasUriElement()) 6945 composeUri(t, "ImplementationGuide", "uri", element.getUriElement(), -1); 6946 } 6947 6948 protected void composeImplementationGuideImplementationGuidePackageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePackageComponent element, int index) { 6949 if (element == null) 6950 return; 6951 Complex t; 6952 if (Utilities.noString(parentType)) 6953 t = parent; 6954 else { 6955 t = parent.predicate("fhir:"+parentType+'.'+name); 6956 } 6957 composeBackboneElement(t, "package", name, element, index); 6958 if (element.hasNameElement()) 6959 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 6960 if (element.hasDescriptionElement()) 6961 composeString(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 6962 for (int i = 0; i < element.getResource().size(); i++) 6963 composeImplementationGuideImplementationGuidePackageResourceComponent(t, "ImplementationGuide", "resource", element.getResource().get(i), i); 6964 } 6965 6966 protected void composeImplementationGuideImplementationGuidePackageResourceComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePackageResourceComponent element, int index) { 6967 if (element == null) 6968 return; 6969 Complex t; 6970 if (Utilities.noString(parentType)) 6971 t = parent; 6972 else { 6973 t = parent.predicate("fhir:"+parentType+'.'+name); 6974 } 6975 composeBackboneElement(t, "resource", name, element, index); 6976 if (element.hasExampleElement()) 6977 composeBoolean(t, "ImplementationGuide", "example", element.getExampleElement(), -1); 6978 if (element.hasNameElement()) 6979 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 6980 if (element.hasDescriptionElement()) 6981 composeString(t, "ImplementationGuide", "description", element.getDescriptionElement(), -1); 6982 if (element.hasAcronymElement()) 6983 composeString(t, "ImplementationGuide", "acronym", element.getAcronymElement(), -1); 6984 if (element.hasSource()) 6985 composeType(t, "ImplementationGuide", "source", element.getSource(), -1); 6986 if (element.hasExampleFor()) 6987 composeReference(t, "ImplementationGuide", "exampleFor", element.getExampleFor(), -1); 6988 } 6989 6990 protected void composeImplementationGuideImplementationGuideGlobalComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuideGlobalComponent element, int index) { 6991 if (element == null) 6992 return; 6993 Complex t; 6994 if (Utilities.noString(parentType)) 6995 t = parent; 6996 else { 6997 t = parent.predicate("fhir:"+parentType+'.'+name); 6998 } 6999 composeBackboneElement(t, "global", name, element, index); 7000 if (element.hasTypeElement()) 7001 composeCode(t, "ImplementationGuide", "type", element.getTypeElement(), -1); 7002 if (element.hasProfile()) 7003 composeReference(t, "ImplementationGuide", "profile", element.getProfile(), -1); 7004 } 7005 7006 protected void composeImplementationGuideImplementationGuidePageComponent(Complex parent, String parentType, String name, ImplementationGuide.ImplementationGuidePageComponent element, int index) { 7007 if (element == null) 7008 return; 7009 Complex t; 7010 if (Utilities.noString(parentType)) 7011 t = parent; 7012 else { 7013 t = parent.predicate("fhir:"+parentType+'.'+name); 7014 } 7015 composeBackboneElement(t, "page", name, element, index); 7016 if (element.hasSourceElement()) 7017 composeUri(t, "ImplementationGuide", "source", element.getSourceElement(), -1); 7018 if (element.hasNameElement()) 7019 composeString(t, "ImplementationGuide", "name", element.getNameElement(), -1); 7020 if (element.hasKindElement()) 7021 composeEnum(t, "ImplementationGuide", "kind", element.getKindElement(), -1); 7022 for (int i = 0; i < element.getType().size(); i++) 7023 composeCode(t, "ImplementationGuide", "type", element.getType().get(i), i); 7024 for (int i = 0; i < element.getPackage().size(); i++) 7025 composeString(t, "ImplementationGuide", "package", element.getPackage().get(i), i); 7026 if (element.hasFormatElement()) 7027 composeCode(t, "ImplementationGuide", "format", element.getFormatElement(), -1); 7028 for (int i = 0; i < element.getPage().size(); i++) 7029 composeImplementationGuideImplementationGuidePageComponent(t, "ImplementationGuide", "page", element.getPage().get(i), i); 7030 } 7031 7032 protected void composeLibrary(Complex parent, String parentType, String name, Library element, int index) { 7033 if (element == null) 7034 return; 7035 Complex t; 7036 if (Utilities.noString(parentType)) 7037 t = parent; 7038 else { 7039 t = parent.predicate("fhir:"+parentType+'.'+name); 7040 } 7041 composeDomainResource(t, "Library", name, element, index); 7042 if (element.hasModuleMetadata()) 7043 composeModuleMetadata(t, "Library", "moduleMetadata", element.getModuleMetadata(), -1); 7044 for (int i = 0; i < element.getModel().size(); i++) 7045 composeLibraryLibraryModelComponent(t, "Library", "model", element.getModel().get(i), i); 7046 for (int i = 0; i < element.getLibrary().size(); i++) 7047 composeLibraryLibraryLibraryComponent(t, "Library", "library", element.getLibrary().get(i), i); 7048 for (int i = 0; i < element.getCodeSystem().size(); i++) 7049 composeLibraryLibraryCodeSystemComponent(t, "Library", "codeSystem", element.getCodeSystem().get(i), i); 7050 for (int i = 0; i < element.getValueSet().size(); i++) 7051 composeLibraryLibraryValueSetComponent(t, "Library", "valueSet", element.getValueSet().get(i), i); 7052 for (int i = 0; i < element.getParameter().size(); i++) 7053 composeParameterDefinition(t, "Library", "parameter", element.getParameter().get(i), i); 7054 for (int i = 0; i < element.getDataRequirement().size(); i++) 7055 composeDataRequirement(t, "Library", "dataRequirement", element.getDataRequirement().get(i), i); 7056 if (element.hasDocument()) 7057 composeAttachment(t, "Library", "document", element.getDocument(), -1); 7058 } 7059 7060 protected void composeLibraryLibraryModelComponent(Complex parent, String parentType, String name, Library.LibraryModelComponent element, int index) { 7061 if (element == null) 7062 return; 7063 Complex t; 7064 if (Utilities.noString(parentType)) 7065 t = parent; 7066 else { 7067 t = parent.predicate("fhir:"+parentType+'.'+name); 7068 } 7069 composeBackboneElement(t, "model", name, element, index); 7070 if (element.hasNameElement()) 7071 composeString(t, "Library", "name", element.getNameElement(), -1); 7072 if (element.hasIdentifierElement()) 7073 composeString(t, "Library", "identifier", element.getIdentifierElement(), -1); 7074 if (element.hasVersionElement()) 7075 composeString(t, "Library", "version", element.getVersionElement(), -1); 7076 } 7077 7078 protected void composeLibraryLibraryLibraryComponent(Complex parent, String parentType, String name, Library.LibraryLibraryComponent element, int index) { 7079 if (element == null) 7080 return; 7081 Complex t; 7082 if (Utilities.noString(parentType)) 7083 t = parent; 7084 else { 7085 t = parent.predicate("fhir:"+parentType+'.'+name); 7086 } 7087 composeBackboneElement(t, "library", name, element, index); 7088 if (element.hasNameElement()) 7089 composeString(t, "Library", "name", element.getNameElement(), -1); 7090 if (element.hasIdentifierElement()) 7091 composeString(t, "Library", "identifier", element.getIdentifierElement(), -1); 7092 if (element.hasVersionElement()) 7093 composeString(t, "Library", "version", element.getVersionElement(), -1); 7094 if (element.hasDocument()) 7095 composeType(t, "Library", "document", element.getDocument(), -1); 7096 } 7097 7098 protected void composeLibraryLibraryCodeSystemComponent(Complex parent, String parentType, String name, Library.LibraryCodeSystemComponent element, int index) { 7099 if (element == null) 7100 return; 7101 Complex t; 7102 if (Utilities.noString(parentType)) 7103 t = parent; 7104 else { 7105 t = parent.predicate("fhir:"+parentType+'.'+name); 7106 } 7107 composeBackboneElement(t, "codeSystem", name, element, index); 7108 if (element.hasNameElement()) 7109 composeString(t, "Library", "name", element.getNameElement(), -1); 7110 if (element.hasIdentifierElement()) 7111 composeString(t, "Library", "identifier", element.getIdentifierElement(), -1); 7112 if (element.hasVersionElement()) 7113 composeString(t, "Library", "version", element.getVersionElement(), -1); 7114 } 7115 7116 protected void composeLibraryLibraryValueSetComponent(Complex parent, String parentType, String name, Library.LibraryValueSetComponent element, int index) { 7117 if (element == null) 7118 return; 7119 Complex t; 7120 if (Utilities.noString(parentType)) 7121 t = parent; 7122 else { 7123 t = parent.predicate("fhir:"+parentType+'.'+name); 7124 } 7125 composeBackboneElement(t, "valueSet", name, element, index); 7126 if (element.hasNameElement()) 7127 composeString(t, "Library", "name", element.getNameElement(), -1); 7128 if (element.hasIdentifierElement()) 7129 composeString(t, "Library", "identifier", element.getIdentifierElement(), -1); 7130 if (element.hasVersionElement()) 7131 composeString(t, "Library", "version", element.getVersionElement(), -1); 7132 for (int i = 0; i < element.getCodeSystem().size(); i++) 7133 composeString(t, "Library", "codeSystem", element.getCodeSystem().get(i), i); 7134 } 7135 7136 protected void composeLinkage(Complex parent, String parentType, String name, Linkage element, int index) { 7137 if (element == null) 7138 return; 7139 Complex t; 7140 if (Utilities.noString(parentType)) 7141 t = parent; 7142 else { 7143 t = parent.predicate("fhir:"+parentType+'.'+name); 7144 } 7145 composeDomainResource(t, "Linkage", name, element, index); 7146 if (element.hasAuthor()) 7147 composeReference(t, "Linkage", "author", element.getAuthor(), -1); 7148 for (int i = 0; i < element.getItem().size(); i++) 7149 composeLinkageLinkageItemComponent(t, "Linkage", "item", element.getItem().get(i), i); 7150 } 7151 7152 protected void composeLinkageLinkageItemComponent(Complex parent, String parentType, String name, Linkage.LinkageItemComponent element, int index) { 7153 if (element == null) 7154 return; 7155 Complex t; 7156 if (Utilities.noString(parentType)) 7157 t = parent; 7158 else { 7159 t = parent.predicate("fhir:"+parentType+'.'+name); 7160 } 7161 composeBackboneElement(t, "item", name, element, index); 7162 if (element.hasTypeElement()) 7163 composeEnum(t, "Linkage", "type", element.getTypeElement(), -1); 7164 if (element.hasResource()) 7165 composeReference(t, "Linkage", "resource", element.getResource(), -1); 7166 } 7167 7168 protected void composeListResource(Complex parent, String parentType, String name, ListResource element, int index) { 7169 if (element == null) 7170 return; 7171 Complex t; 7172 if (Utilities.noString(parentType)) 7173 t = parent; 7174 else { 7175 t = parent.predicate("fhir:"+parentType+'.'+name); 7176 } 7177 composeDomainResource(t, "List", name, element, index); 7178 for (int i = 0; i < element.getIdentifier().size(); i++) 7179 composeIdentifier(t, "List", "identifier", element.getIdentifier().get(i), i); 7180 if (element.hasStatusElement()) 7181 composeEnum(t, "List", "status", element.getStatusElement(), -1); 7182 if (element.hasModeElement()) 7183 composeEnum(t, "List", "mode", element.getModeElement(), -1); 7184 if (element.hasTitleElement()) 7185 composeString(t, "List", "title", element.getTitleElement(), -1); 7186 if (element.hasCode()) 7187 composeCodeableConcept(t, "List", "code", element.getCode(), -1); 7188 if (element.hasSubject()) 7189 composeReference(t, "List", "subject", element.getSubject(), -1); 7190 if (element.hasEncounter()) 7191 composeReference(t, "List", "encounter", element.getEncounter(), -1); 7192 if (element.hasDateElement()) 7193 composeDateTime(t, "List", "date", element.getDateElement(), -1); 7194 if (element.hasSource()) 7195 composeReference(t, "List", "source", element.getSource(), -1); 7196 if (element.hasOrderedBy()) 7197 composeCodeableConcept(t, "List", "orderedBy", element.getOrderedBy(), -1); 7198 for (int i = 0; i < element.getNote().size(); i++) 7199 composeAnnotation(t, "List", "note", element.getNote().get(i), i); 7200 for (int i = 0; i < element.getEntry().size(); i++) 7201 composeListResourceListEntryComponent(t, "List", "entry", element.getEntry().get(i), i); 7202 if (element.hasEmptyReason()) 7203 composeCodeableConcept(t, "List", "emptyReason", element.getEmptyReason(), -1); 7204 } 7205 7206 protected void composeListResourceListEntryComponent(Complex parent, String parentType, String name, ListResource.ListEntryComponent element, int index) { 7207 if (element == null) 7208 return; 7209 Complex t; 7210 if (Utilities.noString(parentType)) 7211 t = parent; 7212 else { 7213 t = parent.predicate("fhir:"+parentType+'.'+name); 7214 } 7215 composeBackboneElement(t, "entry", name, element, index); 7216 if (element.hasFlag()) 7217 composeCodeableConcept(t, "List", "flag", element.getFlag(), -1); 7218 if (element.hasDeletedElement()) 7219 composeBoolean(t, "List", "deleted", element.getDeletedElement(), -1); 7220 if (element.hasDateElement()) 7221 composeDateTime(t, "List", "date", element.getDateElement(), -1); 7222 if (element.hasItem()) 7223 composeReference(t, "List", "item", element.getItem(), -1); 7224 } 7225 7226 protected void composeLocation(Complex parent, String parentType, String name, Location element, int index) { 7227 if (element == null) 7228 return; 7229 Complex t; 7230 if (Utilities.noString(parentType)) 7231 t = parent; 7232 else { 7233 t = parent.predicate("fhir:"+parentType+'.'+name); 7234 } 7235 composeDomainResource(t, "Location", name, element, index); 7236 for (int i = 0; i < element.getIdentifier().size(); i++) 7237 composeIdentifier(t, "Location", "identifier", element.getIdentifier().get(i), i); 7238 if (element.hasStatusElement()) 7239 composeEnum(t, "Location", "status", element.getStatusElement(), -1); 7240 if (element.hasNameElement()) 7241 composeString(t, "Location", "name", element.getNameElement(), -1); 7242 if (element.hasDescriptionElement()) 7243 composeString(t, "Location", "description", element.getDescriptionElement(), -1); 7244 if (element.hasModeElement()) 7245 composeEnum(t, "Location", "mode", element.getModeElement(), -1); 7246 if (element.hasType()) 7247 composeCodeableConcept(t, "Location", "type", element.getType(), -1); 7248 for (int i = 0; i < element.getTelecom().size(); i++) 7249 composeContactPoint(t, "Location", "telecom", element.getTelecom().get(i), i); 7250 if (element.hasAddress()) 7251 composeAddress(t, "Location", "address", element.getAddress(), -1); 7252 if (element.hasPhysicalType()) 7253 composeCodeableConcept(t, "Location", "physicalType", element.getPhysicalType(), -1); 7254 if (element.hasPosition()) 7255 composeLocationLocationPositionComponent(t, "Location", "position", element.getPosition(), -1); 7256 if (element.hasManagingOrganization()) 7257 composeReference(t, "Location", "managingOrganization", element.getManagingOrganization(), -1); 7258 if (element.hasPartOf()) 7259 composeReference(t, "Location", "partOf", element.getPartOf(), -1); 7260 } 7261 7262 protected void composeLocationLocationPositionComponent(Complex parent, String parentType, String name, Location.LocationPositionComponent element, int index) { 7263 if (element == null) 7264 return; 7265 Complex t; 7266 if (Utilities.noString(parentType)) 7267 t = parent; 7268 else { 7269 t = parent.predicate("fhir:"+parentType+'.'+name); 7270 } 7271 composeBackboneElement(t, "position", name, element, index); 7272 if (element.hasLongitudeElement()) 7273 composeDecimal(t, "Location", "longitude", element.getLongitudeElement(), -1); 7274 if (element.hasLatitudeElement()) 7275 composeDecimal(t, "Location", "latitude", element.getLatitudeElement(), -1); 7276 if (element.hasAltitudeElement()) 7277 composeDecimal(t, "Location", "altitude", element.getAltitudeElement(), -1); 7278 } 7279 7280 protected void composeMeasure(Complex parent, String parentType, String name, Measure element, int index) { 7281 if (element == null) 7282 return; 7283 Complex t; 7284 if (Utilities.noString(parentType)) 7285 t = parent; 7286 else { 7287 t = parent.predicate("fhir:"+parentType+'.'+name); 7288 } 7289 composeDomainResource(t, "Measure", name, element, index); 7290 if (element.hasModuleMetadata()) 7291 composeModuleMetadata(t, "Measure", "moduleMetadata", element.getModuleMetadata(), -1); 7292 for (int i = 0; i < element.getLibrary().size(); i++) 7293 composeReference(t, "Measure", "library", element.getLibrary().get(i), i); 7294 if (element.hasDisclaimerElement()) 7295 composeMarkdown(t, "Measure", "disclaimer", element.getDisclaimerElement(), -1); 7296 if (element.hasScoringElement()) 7297 composeEnum(t, "Measure", "scoring", element.getScoringElement(), -1); 7298 for (int i = 0; i < element.getType().size(); i++) 7299 composeEnum(t, "Measure", "type", element.getType().get(i), i); 7300 if (element.hasRiskAdjustmentElement()) 7301 composeString(t, "Measure", "riskAdjustment", element.getRiskAdjustmentElement(), -1); 7302 if (element.hasRateAggregationElement()) 7303 composeString(t, "Measure", "rateAggregation", element.getRateAggregationElement(), -1); 7304 if (element.hasRationaleElement()) 7305 composeMarkdown(t, "Measure", "rationale", element.getRationaleElement(), -1); 7306 if (element.hasClinicalRecommendationStatementElement()) 7307 composeMarkdown(t, "Measure", "clinicalRecommendationStatement", element.getClinicalRecommendationStatementElement(), -1); 7308 if (element.hasImprovementNotationElement()) 7309 composeString(t, "Measure", "improvementNotation", element.getImprovementNotationElement(), -1); 7310 if (element.hasDefinitionElement()) 7311 composeMarkdown(t, "Measure", "definition", element.getDefinitionElement(), -1); 7312 if (element.hasGuidanceElement()) 7313 composeMarkdown(t, "Measure", "guidance", element.getGuidanceElement(), -1); 7314 if (element.hasSetElement()) 7315 composeString(t, "Measure", "set", element.getSetElement(), -1); 7316 for (int i = 0; i < element.getGroup().size(); i++) 7317 composeMeasureMeasureGroupComponent(t, "Measure", "group", element.getGroup().get(i), i); 7318 for (int i = 0; i < element.getSupplementalData().size(); i++) 7319 composeMeasureMeasureSupplementalDataComponent(t, "Measure", "supplementalData", element.getSupplementalData().get(i), i); 7320 } 7321 7322 protected void composeMeasureMeasureGroupComponent(Complex parent, String parentType, String name, Measure.MeasureGroupComponent element, int index) { 7323 if (element == null) 7324 return; 7325 Complex t; 7326 if (Utilities.noString(parentType)) 7327 t = parent; 7328 else { 7329 t = parent.predicate("fhir:"+parentType+'.'+name); 7330 } 7331 composeBackboneElement(t, "group", name, element, index); 7332 if (element.hasIdentifier()) 7333 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7334 if (element.hasNameElement()) 7335 composeString(t, "Measure", "name", element.getNameElement(), -1); 7336 if (element.hasDescriptionElement()) 7337 composeString(t, "Measure", "description", element.getDescriptionElement(), -1); 7338 for (int i = 0; i < element.getPopulation().size(); i++) 7339 composeMeasureMeasureGroupPopulationComponent(t, "Measure", "population", element.getPopulation().get(i), i); 7340 for (int i = 0; i < element.getStratifier().size(); i++) 7341 composeMeasureMeasureGroupStratifierComponent(t, "Measure", "stratifier", element.getStratifier().get(i), i); 7342 } 7343 7344 protected void composeMeasureMeasureGroupPopulationComponent(Complex parent, String parentType, String name, Measure.MeasureGroupPopulationComponent element, int index) { 7345 if (element == null) 7346 return; 7347 Complex t; 7348 if (Utilities.noString(parentType)) 7349 t = parent; 7350 else { 7351 t = parent.predicate("fhir:"+parentType+'.'+name); 7352 } 7353 composeBackboneElement(t, "population", name, element, index); 7354 if (element.hasTypeElement()) 7355 composeEnum(t, "Measure", "type", element.getTypeElement(), -1); 7356 if (element.hasIdentifier()) 7357 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7358 if (element.hasNameElement()) 7359 composeString(t, "Measure", "name", element.getNameElement(), -1); 7360 if (element.hasDescriptionElement()) 7361 composeString(t, "Measure", "description", element.getDescriptionElement(), -1); 7362 if (element.hasCriteriaElement()) 7363 composeString(t, "Measure", "criteria", element.getCriteriaElement(), -1); 7364 } 7365 7366 protected void composeMeasureMeasureGroupStratifierComponent(Complex parent, String parentType, String name, Measure.MeasureGroupStratifierComponent element, int index) { 7367 if (element == null) 7368 return; 7369 Complex t; 7370 if (Utilities.noString(parentType)) 7371 t = parent; 7372 else { 7373 t = parent.predicate("fhir:"+parentType+'.'+name); 7374 } 7375 composeBackboneElement(t, "stratifier", name, element, index); 7376 if (element.hasIdentifier()) 7377 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7378 if (element.hasCriteriaElement()) 7379 composeString(t, "Measure", "criteria", element.getCriteriaElement(), -1); 7380 if (element.hasPathElement()) 7381 composeString(t, "Measure", "path", element.getPathElement(), -1); 7382 } 7383 7384 protected void composeMeasureMeasureSupplementalDataComponent(Complex parent, String parentType, String name, Measure.MeasureSupplementalDataComponent element, int index) { 7385 if (element == null) 7386 return; 7387 Complex t; 7388 if (Utilities.noString(parentType)) 7389 t = parent; 7390 else { 7391 t = parent.predicate("fhir:"+parentType+'.'+name); 7392 } 7393 composeBackboneElement(t, "supplementalData", name, element, index); 7394 if (element.hasIdentifier()) 7395 composeIdentifier(t, "Measure", "identifier", element.getIdentifier(), -1); 7396 for (int i = 0; i < element.getUsage().size(); i++) 7397 composeEnum(t, "Measure", "usage", element.getUsage().get(i), i); 7398 if (element.hasCriteriaElement()) 7399 composeString(t, "Measure", "criteria", element.getCriteriaElement(), -1); 7400 if (element.hasPathElement()) 7401 composeString(t, "Measure", "path", element.getPathElement(), -1); 7402 } 7403 7404 protected void composeMeasureReport(Complex parent, String parentType, String name, MeasureReport element, int index) { 7405 if (element == null) 7406 return; 7407 Complex t; 7408 if (Utilities.noString(parentType)) 7409 t = parent; 7410 else { 7411 t = parent.predicate("fhir:"+parentType+'.'+name); 7412 } 7413 composeDomainResource(t, "MeasureReport", name, element, index); 7414 if (element.hasMeasure()) 7415 composeReference(t, "MeasureReport", "measure", element.getMeasure(), -1); 7416 if (element.hasTypeElement()) 7417 composeEnum(t, "MeasureReport", "type", element.getTypeElement(), -1); 7418 if (element.hasPatient()) 7419 composeReference(t, "MeasureReport", "patient", element.getPatient(), -1); 7420 if (element.hasPeriod()) 7421 composePeriod(t, "MeasureReport", "period", element.getPeriod(), -1); 7422 if (element.hasStatusElement()) 7423 composeEnum(t, "MeasureReport", "status", element.getStatusElement(), -1); 7424 if (element.hasDateElement()) 7425 composeDateTime(t, "MeasureReport", "date", element.getDateElement(), -1); 7426 if (element.hasReportingOrganization()) 7427 composeReference(t, "MeasureReport", "reportingOrganization", element.getReportingOrganization(), -1); 7428 for (int i = 0; i < element.getGroup().size(); i++) 7429 composeMeasureReportMeasureReportGroupComponent(t, "MeasureReport", "group", element.getGroup().get(i), i); 7430 if (element.hasEvaluatedResources()) 7431 composeReference(t, "MeasureReport", "evaluatedResources", element.getEvaluatedResources(), -1); 7432 } 7433 7434 protected void composeMeasureReportMeasureReportGroupComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupComponent element, int index) { 7435 if (element == null) 7436 return; 7437 Complex t; 7438 if (Utilities.noString(parentType)) 7439 t = parent; 7440 else { 7441 t = parent.predicate("fhir:"+parentType+'.'+name); 7442 } 7443 composeBackboneElement(t, "group", name, element, index); 7444 if (element.hasIdentifier()) 7445 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7446 for (int i = 0; i < element.getPopulation().size(); i++) 7447 composeMeasureReportMeasureReportGroupPopulationComponent(t, "MeasureReport", "population", element.getPopulation().get(i), i); 7448 if (element.hasMeasureScoreElement()) 7449 composeDecimal(t, "MeasureReport", "measureScore", element.getMeasureScoreElement(), -1); 7450 for (int i = 0; i < element.getStratifier().size(); i++) 7451 composeMeasureReportMeasureReportGroupStratifierComponent(t, "MeasureReport", "stratifier", element.getStratifier().get(i), i); 7452 for (int i = 0; i < element.getSupplementalData().size(); i++) 7453 composeMeasureReportMeasureReportGroupSupplementalDataComponent(t, "MeasureReport", "supplementalData", element.getSupplementalData().get(i), i); 7454 } 7455 7456 protected void composeMeasureReportMeasureReportGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupPopulationComponent element, int index) { 7457 if (element == null) 7458 return; 7459 Complex t; 7460 if (Utilities.noString(parentType)) 7461 t = parent; 7462 else { 7463 t = parent.predicate("fhir:"+parentType+'.'+name); 7464 } 7465 composeBackboneElement(t, "population", name, element, index); 7466 if (element.hasTypeElement()) 7467 composeCode(t, "MeasureReport", "type", element.getTypeElement(), -1); 7468 if (element.hasCountElement()) 7469 composeInteger(t, "MeasureReport", "count", element.getCountElement(), -1); 7470 if (element.hasPatients()) 7471 composeReference(t, "MeasureReport", "patients", element.getPatients(), -1); 7472 } 7473 7474 protected void composeMeasureReportMeasureReportGroupStratifierComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupStratifierComponent element, int index) { 7475 if (element == null) 7476 return; 7477 Complex t; 7478 if (Utilities.noString(parentType)) 7479 t = parent; 7480 else { 7481 t = parent.predicate("fhir:"+parentType+'.'+name); 7482 } 7483 composeBackboneElement(t, "stratifier", name, element, index); 7484 if (element.hasIdentifier()) 7485 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7486 for (int i = 0; i < element.getGroup().size(); i++) 7487 composeMeasureReportMeasureReportGroupStratifierGroupComponent(t, "MeasureReport", "group", element.getGroup().get(i), i); 7488 } 7489 7490 protected void composeMeasureReportMeasureReportGroupStratifierGroupComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupStratifierGroupComponent element, int index) { 7491 if (element == null) 7492 return; 7493 Complex t; 7494 if (Utilities.noString(parentType)) 7495 t = parent; 7496 else { 7497 t = parent.predicate("fhir:"+parentType+'.'+name); 7498 } 7499 composeBackboneElement(t, "group", name, element, index); 7500 if (element.hasValueElement()) 7501 composeString(t, "MeasureReport", "value", element.getValueElement(), -1); 7502 for (int i = 0; i < element.getPopulation().size(); i++) 7503 composeMeasureReportMeasureReportGroupStratifierGroupPopulationComponent(t, "MeasureReport", "population", element.getPopulation().get(i), i); 7504 if (element.hasMeasureScoreElement()) 7505 composeDecimal(t, "MeasureReport", "measureScore", element.getMeasureScoreElement(), -1); 7506 } 7507 7508 protected void composeMeasureReportMeasureReportGroupStratifierGroupPopulationComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupStratifierGroupPopulationComponent element, int index) { 7509 if (element == null) 7510 return; 7511 Complex t; 7512 if (Utilities.noString(parentType)) 7513 t = parent; 7514 else { 7515 t = parent.predicate("fhir:"+parentType+'.'+name); 7516 } 7517 composeBackboneElement(t, "population", name, element, index); 7518 if (element.hasTypeElement()) 7519 composeCode(t, "MeasureReport", "type", element.getTypeElement(), -1); 7520 if (element.hasCountElement()) 7521 composeInteger(t, "MeasureReport", "count", element.getCountElement(), -1); 7522 if (element.hasPatients()) 7523 composeReference(t, "MeasureReport", "patients", element.getPatients(), -1); 7524 } 7525 7526 protected void composeMeasureReportMeasureReportGroupSupplementalDataComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupSupplementalDataComponent element, int index) { 7527 if (element == null) 7528 return; 7529 Complex t; 7530 if (Utilities.noString(parentType)) 7531 t = parent; 7532 else { 7533 t = parent.predicate("fhir:"+parentType+'.'+name); 7534 } 7535 composeBackboneElement(t, "supplementalData", name, element, index); 7536 if (element.hasIdentifier()) 7537 composeIdentifier(t, "MeasureReport", "identifier", element.getIdentifier(), -1); 7538 for (int i = 0; i < element.getGroup().size(); i++) 7539 composeMeasureReportMeasureReportGroupSupplementalDataGroupComponent(t, "MeasureReport", "group", element.getGroup().get(i), i); 7540 } 7541 7542 protected void composeMeasureReportMeasureReportGroupSupplementalDataGroupComponent(Complex parent, String parentType, String name, MeasureReport.MeasureReportGroupSupplementalDataGroupComponent element, int index) { 7543 if (element == null) 7544 return; 7545 Complex t; 7546 if (Utilities.noString(parentType)) 7547 t = parent; 7548 else { 7549 t = parent.predicate("fhir:"+parentType+'.'+name); 7550 } 7551 composeBackboneElement(t, "group", name, element, index); 7552 if (element.hasValueElement()) 7553 composeString(t, "MeasureReport", "value", element.getValueElement(), -1); 7554 if (element.hasCountElement()) 7555 composeInteger(t, "MeasureReport", "count", element.getCountElement(), -1); 7556 if (element.hasPatients()) 7557 composeReference(t, "MeasureReport", "patients", element.getPatients(), -1); 7558 } 7559 7560 protected void composeMedia(Complex parent, String parentType, String name, Media element, int index) { 7561 if (element == null) 7562 return; 7563 Complex t; 7564 if (Utilities.noString(parentType)) 7565 t = parent; 7566 else { 7567 t = parent.predicate("fhir:"+parentType+'.'+name); 7568 } 7569 composeDomainResource(t, "Media", name, element, index); 7570 for (int i = 0; i < element.getIdentifier().size(); i++) 7571 composeIdentifier(t, "Media", "identifier", element.getIdentifier().get(i), i); 7572 if (element.hasTypeElement()) 7573 composeEnum(t, "Media", "type", element.getTypeElement(), -1); 7574 if (element.hasSubtype()) 7575 composeCodeableConcept(t, "Media", "subtype", element.getSubtype(), -1); 7576 if (element.hasView()) 7577 composeCodeableConcept(t, "Media", "view", element.getView(), -1); 7578 if (element.hasSubject()) 7579 composeReference(t, "Media", "subject", element.getSubject(), -1); 7580 if (element.hasOperator()) 7581 composeReference(t, "Media", "operator", element.getOperator(), -1); 7582 if (element.hasDeviceNameElement()) 7583 composeString(t, "Media", "deviceName", element.getDeviceNameElement(), -1); 7584 if (element.hasHeightElement()) 7585 composePositiveInt(t, "Media", "height", element.getHeightElement(), -1); 7586 if (element.hasWidthElement()) 7587 composePositiveInt(t, "Media", "width", element.getWidthElement(), -1); 7588 if (element.hasFramesElement()) 7589 composePositiveInt(t, "Media", "frames", element.getFramesElement(), -1); 7590 if (element.hasDurationElement()) 7591 composeUnsignedInt(t, "Media", "duration", element.getDurationElement(), -1); 7592 if (element.hasContent()) 7593 composeAttachment(t, "Media", "content", element.getContent(), -1); 7594 } 7595 7596 protected void composeMedication(Complex parent, String parentType, String name, Medication element, int index) { 7597 if (element == null) 7598 return; 7599 Complex t; 7600 if (Utilities.noString(parentType)) 7601 t = parent; 7602 else { 7603 t = parent.predicate("fhir:"+parentType+'.'+name); 7604 } 7605 composeDomainResource(t, "Medication", name, element, index); 7606 if (element.hasCode()) 7607 composeCodeableConcept(t, "Medication", "code", element.getCode(), -1); 7608 if (element.hasIsBrandElement()) 7609 composeBoolean(t, "Medication", "isBrand", element.getIsBrandElement(), -1); 7610 if (element.hasManufacturer()) 7611 composeReference(t, "Medication", "manufacturer", element.getManufacturer(), -1); 7612 if (element.hasProduct()) 7613 composeMedicationMedicationProductComponent(t, "Medication", "product", element.getProduct(), -1); 7614 if (element.hasPackage()) 7615 composeMedicationMedicationPackageComponent(t, "Medication", "package", element.getPackage(), -1); 7616 } 7617 7618 protected void composeMedicationMedicationProductComponent(Complex parent, String parentType, String name, Medication.MedicationProductComponent element, int index) { 7619 if (element == null) 7620 return; 7621 Complex t; 7622 if (Utilities.noString(parentType)) 7623 t = parent; 7624 else { 7625 t = parent.predicate("fhir:"+parentType+'.'+name); 7626 } 7627 composeBackboneElement(t, "product", name, element, index); 7628 if (element.hasForm()) 7629 composeCodeableConcept(t, "Medication", "form", element.getForm(), -1); 7630 for (int i = 0; i < element.getIngredient().size(); i++) 7631 composeMedicationMedicationProductIngredientComponent(t, "Medication", "ingredient", element.getIngredient().get(i), i); 7632 for (int i = 0; i < element.getBatch().size(); i++) 7633 composeMedicationMedicationProductBatchComponent(t, "Medication", "batch", element.getBatch().get(i), i); 7634 } 7635 7636 protected void composeMedicationMedicationProductIngredientComponent(Complex parent, String parentType, String name, Medication.MedicationProductIngredientComponent element, int index) { 7637 if (element == null) 7638 return; 7639 Complex t; 7640 if (Utilities.noString(parentType)) 7641 t = parent; 7642 else { 7643 t = parent.predicate("fhir:"+parentType+'.'+name); 7644 } 7645 composeBackboneElement(t, "ingredient", name, element, index); 7646 if (element.hasItem()) 7647 composeType(t, "Medication", "item", element.getItem(), -1); 7648 if (element.hasAmount()) 7649 composeRatio(t, "Medication", "amount", element.getAmount(), -1); 7650 } 7651 7652 protected void composeMedicationMedicationProductBatchComponent(Complex parent, String parentType, String name, Medication.MedicationProductBatchComponent element, int index) { 7653 if (element == null) 7654 return; 7655 Complex t; 7656 if (Utilities.noString(parentType)) 7657 t = parent; 7658 else { 7659 t = parent.predicate("fhir:"+parentType+'.'+name); 7660 } 7661 composeBackboneElement(t, "batch", name, element, index); 7662 if (element.hasLotNumberElement()) 7663 composeString(t, "Medication", "lotNumber", element.getLotNumberElement(), -1); 7664 if (element.hasExpirationDateElement()) 7665 composeDateTime(t, "Medication", "expirationDate", element.getExpirationDateElement(), -1); 7666 } 7667 7668 protected void composeMedicationMedicationPackageComponent(Complex parent, String parentType, String name, Medication.MedicationPackageComponent element, int index) { 7669 if (element == null) 7670 return; 7671 Complex t; 7672 if (Utilities.noString(parentType)) 7673 t = parent; 7674 else { 7675 t = parent.predicate("fhir:"+parentType+'.'+name); 7676 } 7677 composeBackboneElement(t, "package", name, element, index); 7678 if (element.hasContainer()) 7679 composeCodeableConcept(t, "Medication", "container", element.getContainer(), -1); 7680 for (int i = 0; i < element.getContent().size(); i++) 7681 composeMedicationMedicationPackageContentComponent(t, "Medication", "content", element.getContent().get(i), i); 7682 } 7683 7684 protected void composeMedicationMedicationPackageContentComponent(Complex parent, String parentType, String name, Medication.MedicationPackageContentComponent element, int index) { 7685 if (element == null) 7686 return; 7687 Complex t; 7688 if (Utilities.noString(parentType)) 7689 t = parent; 7690 else { 7691 t = parent.predicate("fhir:"+parentType+'.'+name); 7692 } 7693 composeBackboneElement(t, "content", name, element, index); 7694 if (element.hasItem()) 7695 composeType(t, "Medication", "item", element.getItem(), -1); 7696 if (element.hasAmount()) 7697 composeQuantity(t, "Medication", "amount", element.getAmount(), -1); 7698 } 7699 7700 protected void composeMedicationAdministration(Complex parent, String parentType, String name, MedicationAdministration element, int index) { 7701 if (element == null) 7702 return; 7703 Complex t; 7704 if (Utilities.noString(parentType)) 7705 t = parent; 7706 else { 7707 t = parent.predicate("fhir:"+parentType+'.'+name); 7708 } 7709 composeDomainResource(t, "MedicationAdministration", name, element, index); 7710 for (int i = 0; i < element.getIdentifier().size(); i++) 7711 composeIdentifier(t, "MedicationAdministration", "identifier", element.getIdentifier().get(i), i); 7712 if (element.hasStatusElement()) 7713 composeEnum(t, "MedicationAdministration", "status", element.getStatusElement(), -1); 7714 if (element.hasMedication()) 7715 composeType(t, "MedicationAdministration", "medication", element.getMedication(), -1); 7716 if (element.hasPatient()) 7717 composeReference(t, "MedicationAdministration", "patient", element.getPatient(), -1); 7718 if (element.hasEncounter()) 7719 composeReference(t, "MedicationAdministration", "encounter", element.getEncounter(), -1); 7720 if (element.hasEffectiveTime()) 7721 composeType(t, "MedicationAdministration", "effectiveTime", element.getEffectiveTime(), -1); 7722 if (element.hasPractitioner()) 7723 composeReference(t, "MedicationAdministration", "practitioner", element.getPractitioner(), -1); 7724 if (element.hasPrescription()) 7725 composeReference(t, "MedicationAdministration", "prescription", element.getPrescription(), -1); 7726 if (element.hasWasNotGivenElement()) 7727 composeBoolean(t, "MedicationAdministration", "wasNotGiven", element.getWasNotGivenElement(), -1); 7728 for (int i = 0; i < element.getReasonNotGiven().size(); i++) 7729 composeCodeableConcept(t, "MedicationAdministration", "reasonNotGiven", element.getReasonNotGiven().get(i), i); 7730 for (int i = 0; i < element.getReasonGiven().size(); i++) 7731 composeCodeableConcept(t, "MedicationAdministration", "reasonGiven", element.getReasonGiven().get(i), i); 7732 for (int i = 0; i < element.getDevice().size(); i++) 7733 composeReference(t, "MedicationAdministration", "device", element.getDevice().get(i), i); 7734 for (int i = 0; i < element.getNote().size(); i++) 7735 composeAnnotation(t, "MedicationAdministration", "note", element.getNote().get(i), i); 7736 if (element.hasDosage()) 7737 composeMedicationAdministrationMedicationAdministrationDosageComponent(t, "MedicationAdministration", "dosage", element.getDosage(), -1); 7738 } 7739 7740 protected void composeMedicationAdministrationMedicationAdministrationDosageComponent(Complex parent, String parentType, String name, MedicationAdministration.MedicationAdministrationDosageComponent element, int index) { 7741 if (element == null) 7742 return; 7743 Complex t; 7744 if (Utilities.noString(parentType)) 7745 t = parent; 7746 else { 7747 t = parent.predicate("fhir:"+parentType+'.'+name); 7748 } 7749 composeBackboneElement(t, "dosage", name, element, index); 7750 if (element.hasTextElement()) 7751 composeString(t, "MedicationAdministration", "text", element.getTextElement(), -1); 7752 if (element.hasSite()) 7753 composeType(t, "MedicationAdministration", "site", element.getSite(), -1); 7754 if (element.hasRoute()) 7755 composeCodeableConcept(t, "MedicationAdministration", "route", element.getRoute(), -1); 7756 if (element.hasMethod()) 7757 composeCodeableConcept(t, "MedicationAdministration", "method", element.getMethod(), -1); 7758 if (element.hasQuantity()) 7759 composeQuantity(t, "MedicationAdministration", "quantity", element.getQuantity(), -1); 7760 if (element.hasRate()) 7761 composeType(t, "MedicationAdministration", "rate", element.getRate(), -1); 7762 } 7763 7764 protected void composeMedicationDispense(Complex parent, String parentType, String name, MedicationDispense element, int index) { 7765 if (element == null) 7766 return; 7767 Complex t; 7768 if (Utilities.noString(parentType)) 7769 t = parent; 7770 else { 7771 t = parent.predicate("fhir:"+parentType+'.'+name); 7772 } 7773 composeDomainResource(t, "MedicationDispense", name, element, index); 7774 if (element.hasIdentifier()) 7775 composeIdentifier(t, "MedicationDispense", "identifier", element.getIdentifier(), -1); 7776 if (element.hasStatusElement()) 7777 composeEnum(t, "MedicationDispense", "status", element.getStatusElement(), -1); 7778 if (element.hasMedication()) 7779 composeType(t, "MedicationDispense", "medication", element.getMedication(), -1); 7780 if (element.hasPatient()) 7781 composeReference(t, "MedicationDispense", "patient", element.getPatient(), -1); 7782 if (element.hasDispenser()) 7783 composeReference(t, "MedicationDispense", "dispenser", element.getDispenser(), -1); 7784 for (int i = 0; i < element.getAuthorizingPrescription().size(); i++) 7785 composeReference(t, "MedicationDispense", "authorizingPrescription", element.getAuthorizingPrescription().get(i), i); 7786 if (element.hasType()) 7787 composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1); 7788 if (element.hasQuantity()) 7789 composeQuantity(t, "MedicationDispense", "quantity", element.getQuantity(), -1); 7790 if (element.hasDaysSupply()) 7791 composeQuantity(t, "MedicationDispense", "daysSupply", element.getDaysSupply(), -1); 7792 if (element.hasWhenPreparedElement()) 7793 composeDateTime(t, "MedicationDispense", "whenPrepared", element.getWhenPreparedElement(), -1); 7794 if (element.hasWhenHandedOverElement()) 7795 composeDateTime(t, "MedicationDispense", "whenHandedOver", element.getWhenHandedOverElement(), -1); 7796 if (element.hasDestination()) 7797 composeReference(t, "MedicationDispense", "destination", element.getDestination(), -1); 7798 for (int i = 0; i < element.getReceiver().size(); i++) 7799 composeReference(t, "MedicationDispense", "receiver", element.getReceiver().get(i), i); 7800 for (int i = 0; i < element.getNote().size(); i++) 7801 composeAnnotation(t, "MedicationDispense", "note", element.getNote().get(i), i); 7802 for (int i = 0; i < element.getDosageInstruction().size(); i++) 7803 composeMedicationDispenseMedicationDispenseDosageInstructionComponent(t, "MedicationDispense", "dosageInstruction", element.getDosageInstruction().get(i), i); 7804 if (element.hasSubstitution()) 7805 composeMedicationDispenseMedicationDispenseSubstitutionComponent(t, "MedicationDispense", "substitution", element.getSubstitution(), -1); 7806 } 7807 7808 protected void composeMedicationDispenseMedicationDispenseDosageInstructionComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispenseDosageInstructionComponent element, int index) { 7809 if (element == null) 7810 return; 7811 Complex t; 7812 if (Utilities.noString(parentType)) 7813 t = parent; 7814 else { 7815 t = parent.predicate("fhir:"+parentType+'.'+name); 7816 } 7817 composeBackboneElement(t, "dosageInstruction", name, element, index); 7818 if (element.hasTextElement()) 7819 composeString(t, "MedicationDispense", "text", element.getTextElement(), -1); 7820 if (element.hasAdditionalInstructions()) 7821 composeCodeableConcept(t, "MedicationDispense", "additionalInstructions", element.getAdditionalInstructions(), -1); 7822 if (element.hasTiming()) 7823 composeTiming(t, "MedicationDispense", "timing", element.getTiming(), -1); 7824 if (element.hasAsNeeded()) 7825 composeType(t, "MedicationDispense", "asNeeded", element.getAsNeeded(), -1); 7826 if (element.hasSite()) 7827 composeType(t, "MedicationDispense", "site", element.getSite(), -1); 7828 if (element.hasRoute()) 7829 composeCodeableConcept(t, "MedicationDispense", "route", element.getRoute(), -1); 7830 if (element.hasMethod()) 7831 composeCodeableConcept(t, "MedicationDispense", "method", element.getMethod(), -1); 7832 if (element.hasDose()) 7833 composeType(t, "MedicationDispense", "dose", element.getDose(), -1); 7834 if (element.hasRate()) 7835 composeType(t, "MedicationDispense", "rate", element.getRate(), -1); 7836 if (element.hasMaxDosePerPeriod()) 7837 composeRatio(t, "MedicationDispense", "maxDosePerPeriod", element.getMaxDosePerPeriod(), -1); 7838 } 7839 7840 protected void composeMedicationDispenseMedicationDispenseSubstitutionComponent(Complex parent, String parentType, String name, MedicationDispense.MedicationDispenseSubstitutionComponent element, int index) { 7841 if (element == null) 7842 return; 7843 Complex t; 7844 if (Utilities.noString(parentType)) 7845 t = parent; 7846 else { 7847 t = parent.predicate("fhir:"+parentType+'.'+name); 7848 } 7849 composeBackboneElement(t, "substitution", name, element, index); 7850 if (element.hasType()) 7851 composeCodeableConcept(t, "MedicationDispense", "type", element.getType(), -1); 7852 for (int i = 0; i < element.getReason().size(); i++) 7853 composeCodeableConcept(t, "MedicationDispense", "reason", element.getReason().get(i), i); 7854 for (int i = 0; i < element.getResponsibleParty().size(); i++) 7855 composeReference(t, "MedicationDispense", "responsibleParty", element.getResponsibleParty().get(i), i); 7856 } 7857 7858 protected void composeMedicationOrder(Complex parent, String parentType, String name, MedicationOrder element, int index) { 7859 if (element == null) 7860 return; 7861 Complex t; 7862 if (Utilities.noString(parentType)) 7863 t = parent; 7864 else { 7865 t = parent.predicate("fhir:"+parentType+'.'+name); 7866 } 7867 composeDomainResource(t, "MedicationOrder", name, element, index); 7868 for (int i = 0; i < element.getIdentifier().size(); i++) 7869 composeIdentifier(t, "MedicationOrder", "identifier", element.getIdentifier().get(i), i); 7870 if (element.hasStatusElement()) 7871 composeEnum(t, "MedicationOrder", "status", element.getStatusElement(), -1); 7872 if (element.hasMedication()) 7873 composeType(t, "MedicationOrder", "medication", element.getMedication(), -1); 7874 if (element.hasPatient()) 7875 composeReference(t, "MedicationOrder", "patient", element.getPatient(), -1); 7876 if (element.hasEncounter()) 7877 composeReference(t, "MedicationOrder", "encounter", element.getEncounter(), -1); 7878 if (element.hasDateWrittenElement()) 7879 composeDateTime(t, "MedicationOrder", "dateWritten", element.getDateWrittenElement(), -1); 7880 if (element.hasPrescriber()) 7881 composeReference(t, "MedicationOrder", "prescriber", element.getPrescriber(), -1); 7882 for (int i = 0; i < element.getReasonCode().size(); i++) 7883 composeCodeableConcept(t, "MedicationOrder", "reasonCode", element.getReasonCode().get(i), i); 7884 for (int i = 0; i < element.getReasonReference().size(); i++) 7885 composeReference(t, "MedicationOrder", "reasonReference", element.getReasonReference().get(i), i); 7886 if (element.hasDateEndedElement()) 7887 composeDateTime(t, "MedicationOrder", "dateEnded", element.getDateEndedElement(), -1); 7888 if (element.hasReasonEnded()) 7889 composeCodeableConcept(t, "MedicationOrder", "reasonEnded", element.getReasonEnded(), -1); 7890 for (int i = 0; i < element.getNote().size(); i++) 7891 composeAnnotation(t, "MedicationOrder", "note", element.getNote().get(i), i); 7892 for (int i = 0; i < element.getDosageInstruction().size(); i++) 7893 composeMedicationOrderMedicationOrderDosageInstructionComponent(t, "MedicationOrder", "dosageInstruction", element.getDosageInstruction().get(i), i); 7894 if (element.hasDispenseRequest()) 7895 composeMedicationOrderMedicationOrderDispenseRequestComponent(t, "MedicationOrder", "dispenseRequest", element.getDispenseRequest(), -1); 7896 if (element.hasSubstitution()) 7897 composeMedicationOrderMedicationOrderSubstitutionComponent(t, "MedicationOrder", "substitution", element.getSubstitution(), -1); 7898 if (element.hasPriorPrescription()) 7899 composeReference(t, "MedicationOrder", "priorPrescription", element.getPriorPrescription(), -1); 7900 } 7901 7902 protected void composeMedicationOrderMedicationOrderDosageInstructionComponent(Complex parent, String parentType, String name, MedicationOrder.MedicationOrderDosageInstructionComponent element, int index) { 7903 if (element == null) 7904 return; 7905 Complex t; 7906 if (Utilities.noString(parentType)) 7907 t = parent; 7908 else { 7909 t = parent.predicate("fhir:"+parentType+'.'+name); 7910 } 7911 composeBackboneElement(t, "dosageInstruction", name, element, index); 7912 if (element.hasTextElement()) 7913 composeString(t, "MedicationOrder", "text", element.getTextElement(), -1); 7914 if (element.hasAdditionalInstructions()) 7915 composeCodeableConcept(t, "MedicationOrder", "additionalInstructions", element.getAdditionalInstructions(), -1); 7916 if (element.hasTiming()) 7917 composeTiming(t, "MedicationOrder", "timing", element.getTiming(), -1); 7918 if (element.hasAsNeeded()) 7919 composeType(t, "MedicationOrder", "asNeeded", element.getAsNeeded(), -1); 7920 if (element.hasSite()) 7921 composeType(t, "MedicationOrder", "site", element.getSite(), -1); 7922 if (element.hasRoute()) 7923 composeCodeableConcept(t, "MedicationOrder", "route", element.getRoute(), -1); 7924 if (element.hasMethod()) 7925 composeCodeableConcept(t, "MedicationOrder", "method", element.getMethod(), -1); 7926 if (element.hasDose()) 7927 composeType(t, "MedicationOrder", "dose", element.getDose(), -1); 7928 if (element.hasRate()) 7929 composeType(t, "MedicationOrder", "rate", element.getRate(), -1); 7930 if (element.hasMaxDosePerPeriod()) 7931 composeRatio(t, "MedicationOrder", "maxDosePerPeriod", element.getMaxDosePerPeriod(), -1); 7932 } 7933 7934 protected void composeMedicationOrderMedicationOrderDispenseRequestComponent(Complex parent, String parentType, String name, MedicationOrder.MedicationOrderDispenseRequestComponent element, int index) { 7935 if (element == null) 7936 return; 7937 Complex t; 7938 if (Utilities.noString(parentType)) 7939 t = parent; 7940 else { 7941 t = parent.predicate("fhir:"+parentType+'.'+name); 7942 } 7943 composeBackboneElement(t, "dispenseRequest", name, element, index); 7944 if (element.hasMedication()) 7945 composeType(t, "MedicationOrder", "medication", element.getMedication(), -1); 7946 if (element.hasValidityPeriod()) 7947 composePeriod(t, "MedicationOrder", "validityPeriod", element.getValidityPeriod(), -1); 7948 if (element.hasNumberOfRepeatsAllowedElement()) 7949 composePositiveInt(t, "MedicationOrder", "numberOfRepeatsAllowed", element.getNumberOfRepeatsAllowedElement(), -1); 7950 if (element.hasQuantity()) 7951 composeQuantity(t, "MedicationOrder", "quantity", element.getQuantity(), -1); 7952 if (element.hasExpectedSupplyDuration()) 7953 composeQuantity(t, "MedicationOrder", "expectedSupplyDuration", element.getExpectedSupplyDuration(), -1); 7954 } 7955 7956 protected void composeMedicationOrderMedicationOrderSubstitutionComponent(Complex parent, String parentType, String name, MedicationOrder.MedicationOrderSubstitutionComponent element, int index) { 7957 if (element == null) 7958 return; 7959 Complex t; 7960 if (Utilities.noString(parentType)) 7961 t = parent; 7962 else { 7963 t = parent.predicate("fhir:"+parentType+'.'+name); 7964 } 7965 composeBackboneElement(t, "substitution", name, element, index); 7966 if (element.hasType()) 7967 composeCodeableConcept(t, "MedicationOrder", "type", element.getType(), -1); 7968 if (element.hasReason()) 7969 composeCodeableConcept(t, "MedicationOrder", "reason", element.getReason(), -1); 7970 } 7971 7972 protected void composeMedicationStatement(Complex parent, String parentType, String name, MedicationStatement element, int index) { 7973 if (element == null) 7974 return; 7975 Complex t; 7976 if (Utilities.noString(parentType)) 7977 t = parent; 7978 else { 7979 t = parent.predicate("fhir:"+parentType+'.'+name); 7980 } 7981 composeDomainResource(t, "MedicationStatement", name, element, index); 7982 for (int i = 0; i < element.getIdentifier().size(); i++) 7983 composeIdentifier(t, "MedicationStatement", "identifier", element.getIdentifier().get(i), i); 7984 if (element.hasStatusElement()) 7985 composeEnum(t, "MedicationStatement", "status", element.getStatusElement(), -1); 7986 if (element.hasMedication()) 7987 composeType(t, "MedicationStatement", "medication", element.getMedication(), -1); 7988 if (element.hasPatient()) 7989 composeReference(t, "MedicationStatement", "patient", element.getPatient(), -1); 7990 if (element.hasEffective()) 7991 composeType(t, "MedicationStatement", "effective", element.getEffective(), -1); 7992 if (element.hasInformationSource()) 7993 composeReference(t, "MedicationStatement", "informationSource", element.getInformationSource(), -1); 7994 for (int i = 0; i < element.getSupportingInformation().size(); i++) 7995 composeReference(t, "MedicationStatement", "supportingInformation", element.getSupportingInformation().get(i), i); 7996 if (element.hasDateAssertedElement()) 7997 composeDateTime(t, "MedicationStatement", "dateAsserted", element.getDateAssertedElement(), -1); 7998 if (element.hasWasNotTakenElement()) 7999 composeBoolean(t, "MedicationStatement", "wasNotTaken", element.getWasNotTakenElement(), -1); 8000 for (int i = 0; i < element.getReasonNotTaken().size(); i++) 8001 composeCodeableConcept(t, "MedicationStatement", "reasonNotTaken", element.getReasonNotTaken().get(i), i); 8002 if (element.hasReasonForUse()) 8003 composeType(t, "MedicationStatement", "reasonForUse", element.getReasonForUse(), -1); 8004 for (int i = 0; i < element.getNote().size(); i++) 8005 composeAnnotation(t, "MedicationStatement", "note", element.getNote().get(i), i); 8006 for (int i = 0; i < element.getDosage().size(); i++) 8007 composeMedicationStatementMedicationStatementDosageComponent(t, "MedicationStatement", "dosage", element.getDosage().get(i), i); 8008 } 8009 8010 protected void composeMedicationStatementMedicationStatementDosageComponent(Complex parent, String parentType, String name, MedicationStatement.MedicationStatementDosageComponent element, int index) { 8011 if (element == null) 8012 return; 8013 Complex t; 8014 if (Utilities.noString(parentType)) 8015 t = parent; 8016 else { 8017 t = parent.predicate("fhir:"+parentType+'.'+name); 8018 } 8019 composeBackboneElement(t, "dosage", name, element, index); 8020 if (element.hasTextElement()) 8021 composeString(t, "MedicationStatement", "text", element.getTextElement(), -1); 8022 if (element.hasTiming()) 8023 composeTiming(t, "MedicationStatement", "timing", element.getTiming(), -1); 8024 if (element.hasAsNeeded()) 8025 composeType(t, "MedicationStatement", "asNeeded", element.getAsNeeded(), -1); 8026 if (element.hasSite()) 8027 composeType(t, "MedicationStatement", "site", element.getSite(), -1); 8028 if (element.hasRoute()) 8029 composeCodeableConcept(t, "MedicationStatement", "route", element.getRoute(), -1); 8030 if (element.hasMethod()) 8031 composeCodeableConcept(t, "MedicationStatement", "method", element.getMethod(), -1); 8032 if (element.hasQuantity()) 8033 composeType(t, "MedicationStatement", "quantity", element.getQuantity(), -1); 8034 if (element.hasRate()) 8035 composeType(t, "MedicationStatement", "rate", element.getRate(), -1); 8036 if (element.hasMaxDosePerPeriod()) 8037 composeRatio(t, "MedicationStatement", "maxDosePerPeriod", element.getMaxDosePerPeriod(), -1); 8038 } 8039 8040 protected void composeMessageHeader(Complex parent, String parentType, String name, MessageHeader element, int index) { 8041 if (element == null) 8042 return; 8043 Complex t; 8044 if (Utilities.noString(parentType)) 8045 t = parent; 8046 else { 8047 t = parent.predicate("fhir:"+parentType+'.'+name); 8048 } 8049 composeDomainResource(t, "MessageHeader", name, element, index); 8050 if (element.hasTimestampElement()) 8051 composeInstant(t, "MessageHeader", "timestamp", element.getTimestampElement(), -1); 8052 if (element.hasEvent()) 8053 composeCoding(t, "MessageHeader", "event", element.getEvent(), -1); 8054 if (element.hasResponse()) 8055 composeMessageHeaderMessageHeaderResponseComponent(t, "MessageHeader", "response", element.getResponse(), -1); 8056 if (element.hasSource()) 8057 composeMessageHeaderMessageSourceComponent(t, "MessageHeader", "source", element.getSource(), -1); 8058 for (int i = 0; i < element.getDestination().size(); i++) 8059 composeMessageHeaderMessageDestinationComponent(t, "MessageHeader", "destination", element.getDestination().get(i), i); 8060 if (element.hasEnterer()) 8061 composeReference(t, "MessageHeader", "enterer", element.getEnterer(), -1); 8062 if (element.hasAuthor()) 8063 composeReference(t, "MessageHeader", "author", element.getAuthor(), -1); 8064 if (element.hasReceiver()) 8065 composeReference(t, "MessageHeader", "receiver", element.getReceiver(), -1); 8066 if (element.hasResponsible()) 8067 composeReference(t, "MessageHeader", "responsible", element.getResponsible(), -1); 8068 if (element.hasReason()) 8069 composeCodeableConcept(t, "MessageHeader", "reason", element.getReason(), -1); 8070 for (int i = 0; i < element.getData().size(); i++) 8071 composeReference(t, "MessageHeader", "data", element.getData().get(i), i); 8072 } 8073 8074 protected void composeMessageHeaderMessageHeaderResponseComponent(Complex parent, String parentType, String name, MessageHeader.MessageHeaderResponseComponent element, int index) { 8075 if (element == null) 8076 return; 8077 Complex t; 8078 if (Utilities.noString(parentType)) 8079 t = parent; 8080 else { 8081 t = parent.predicate("fhir:"+parentType+'.'+name); 8082 } 8083 composeBackboneElement(t, "response", name, element, index); 8084 if (element.hasIdentifierElement()) 8085 composeId(t, "MessageHeader", "identifier", element.getIdentifierElement(), -1); 8086 if (element.hasCodeElement()) 8087 composeEnum(t, "MessageHeader", "code", element.getCodeElement(), -1); 8088 if (element.hasDetails()) 8089 composeReference(t, "MessageHeader", "details", element.getDetails(), -1); 8090 } 8091 8092 protected void composeMessageHeaderMessageSourceComponent(Complex parent, String parentType, String name, MessageHeader.MessageSourceComponent element, int index) { 8093 if (element == null) 8094 return; 8095 Complex t; 8096 if (Utilities.noString(parentType)) 8097 t = parent; 8098 else { 8099 t = parent.predicate("fhir:"+parentType+'.'+name); 8100 } 8101 composeBackboneElement(t, "source", name, element, index); 8102 if (element.hasNameElement()) 8103 composeString(t, "MessageHeader", "name", element.getNameElement(), -1); 8104 if (element.hasSoftwareElement()) 8105 composeString(t, "MessageHeader", "software", element.getSoftwareElement(), -1); 8106 if (element.hasVersionElement()) 8107 composeString(t, "MessageHeader", "version", element.getVersionElement(), -1); 8108 if (element.hasContact()) 8109 composeContactPoint(t, "MessageHeader", "contact", element.getContact(), -1); 8110 if (element.hasEndpointElement()) 8111 composeUri(t, "MessageHeader", "endpoint", element.getEndpointElement(), -1); 8112 } 8113 8114 protected void composeMessageHeaderMessageDestinationComponent(Complex parent, String parentType, String name, MessageHeader.MessageDestinationComponent element, int index) { 8115 if (element == null) 8116 return; 8117 Complex t; 8118 if (Utilities.noString(parentType)) 8119 t = parent; 8120 else { 8121 t = parent.predicate("fhir:"+parentType+'.'+name); 8122 } 8123 composeBackboneElement(t, "destination", name, element, index); 8124 if (element.hasNameElement()) 8125 composeString(t, "MessageHeader", "name", element.getNameElement(), -1); 8126 if (element.hasTarget()) 8127 composeReference(t, "MessageHeader", "target", element.getTarget(), -1); 8128 if (element.hasEndpointElement()) 8129 composeUri(t, "MessageHeader", "endpoint", element.getEndpointElement(), -1); 8130 } 8131 8132 protected void composeModuleDefinition(Complex parent, String parentType, String name, ModuleDefinition element, int index) { 8133 if (element == null) 8134 return; 8135 Complex t; 8136 if (Utilities.noString(parentType)) 8137 t = parent; 8138 else { 8139 t = parent.predicate("fhir:"+parentType+'.'+name); 8140 } 8141 composeDomainResource(t, "ModuleDefinition", name, element, index); 8142 for (int i = 0; i < element.getIdentifier().size(); i++) 8143 composeIdentifier(t, "ModuleDefinition", "identifier", element.getIdentifier().get(i), i); 8144 if (element.hasVersionElement()) 8145 composeString(t, "ModuleDefinition", "version", element.getVersionElement(), -1); 8146 for (int i = 0; i < element.getModel().size(); i++) 8147 composeModuleDefinitionModuleDefinitionModelComponent(t, "ModuleDefinition", "model", element.getModel().get(i), i); 8148 for (int i = 0; i < element.getLibrary().size(); i++) 8149 composeModuleDefinitionModuleDefinitionLibraryComponent(t, "ModuleDefinition", "library", element.getLibrary().get(i), i); 8150 for (int i = 0; i < element.getCodeSystem().size(); i++) 8151 composeModuleDefinitionModuleDefinitionCodeSystemComponent(t, "ModuleDefinition", "codeSystem", element.getCodeSystem().get(i), i); 8152 for (int i = 0; i < element.getValueSet().size(); i++) 8153 composeModuleDefinitionModuleDefinitionValueSetComponent(t, "ModuleDefinition", "valueSet", element.getValueSet().get(i), i); 8154 for (int i = 0; i < element.getParameter().size(); i++) 8155 composeModuleDefinitionModuleDefinitionParameterComponent(t, "ModuleDefinition", "parameter", element.getParameter().get(i), i); 8156 for (int i = 0; i < element.getData().size(); i++) 8157 composeModuleDefinitionModuleDefinitionDataComponent(t, "ModuleDefinition", "data", element.getData().get(i), i); 8158 } 8159 8160 protected void composeModuleDefinitionModuleDefinitionModelComponent(Complex parent, String parentType, String name, ModuleDefinition.ModuleDefinitionModelComponent element, int index) { 8161 if (element == null) 8162 return; 8163 Complex t; 8164 if (Utilities.noString(parentType)) 8165 t = parent; 8166 else { 8167 t = parent.predicate("fhir:"+parentType+'.'+name); 8168 } 8169 composeBackboneElement(t, "model", name, element, index); 8170 if (element.hasNameElement()) 8171 composeString(t, "ModuleDefinition", "name", element.getNameElement(), -1); 8172 if (element.hasIdentifierElement()) 8173 composeString(t, "ModuleDefinition", "identifier", element.getIdentifierElement(), -1); 8174 if (element.hasVersionElement()) 8175 composeString(t, "ModuleDefinition", "version", element.getVersionElement(), -1); 8176 } 8177 8178 protected void composeModuleDefinitionModuleDefinitionLibraryComponent(Complex parent, String parentType, String name, ModuleDefinition.ModuleDefinitionLibraryComponent element, int index) { 8179 if (element == null) 8180 return; 8181 Complex t; 8182 if (Utilities.noString(parentType)) 8183 t = parent; 8184 else { 8185 t = parent.predicate("fhir:"+parentType+'.'+name); 8186 } 8187 composeBackboneElement(t, "library", name, element, index); 8188 if (element.hasNameElement()) 8189 composeString(t, "ModuleDefinition", "name", element.getNameElement(), -1); 8190 if (element.hasIdentifierElement()) 8191 composeString(t, "ModuleDefinition", "identifier", element.getIdentifierElement(), -1); 8192 if (element.hasVersionElement()) 8193 composeString(t, "ModuleDefinition", "version", element.getVersionElement(), -1); 8194 if (element.hasDocument()) 8195 composeType(t, "ModuleDefinition", "document", element.getDocument(), -1); 8196 } 8197 8198 protected void composeModuleDefinitionModuleDefinitionCodeSystemComponent(Complex parent, String parentType, String name, ModuleDefinition.ModuleDefinitionCodeSystemComponent element, int index) { 8199 if (element == null) 8200 return; 8201 Complex t; 8202 if (Utilities.noString(parentType)) 8203 t = parent; 8204 else { 8205 t = parent.predicate("fhir:"+parentType+'.'+name); 8206 } 8207 composeBackboneElement(t, "codeSystem", name, element, index); 8208 if (element.hasNameElement()) 8209 composeString(t, "ModuleDefinition", "name", element.getNameElement(), -1); 8210 if (element.hasIdentifierElement()) 8211 composeString(t, "ModuleDefinition", "identifier", element.getIdentifierElement(), -1); 8212 if (element.hasVersionElement()) 8213 composeString(t, "ModuleDefinition", "version", element.getVersionElement(), -1); 8214 } 8215 8216 protected void composeModuleDefinitionModuleDefinitionValueSetComponent(Complex parent, String parentType, String name, ModuleDefinition.ModuleDefinitionValueSetComponent element, int index) { 8217 if (element == null) 8218 return; 8219 Complex t; 8220 if (Utilities.noString(parentType)) 8221 t = parent; 8222 else { 8223 t = parent.predicate("fhir:"+parentType+'.'+name); 8224 } 8225 composeBackboneElement(t, "valueSet", name, element, index); 8226 if (element.hasNameElement()) 8227 composeString(t, "ModuleDefinition", "name", element.getNameElement(), -1); 8228 if (element.hasIdentifierElement()) 8229 composeString(t, "ModuleDefinition", "identifier", element.getIdentifierElement(), -1); 8230 if (element.hasVersionElement()) 8231 composeString(t, "ModuleDefinition", "version", element.getVersionElement(), -1); 8232 for (int i = 0; i < element.getCodeSystem().size(); i++) 8233 composeString(t, "ModuleDefinition", "codeSystem", element.getCodeSystem().get(i), i); 8234 } 8235 8236 protected void composeModuleDefinitionModuleDefinitionParameterComponent(Complex parent, String parentType, String name, ModuleDefinition.ModuleDefinitionParameterComponent element, int index) { 8237 if (element == null) 8238 return; 8239 Complex t; 8240 if (Utilities.noString(parentType)) 8241 t = parent; 8242 else { 8243 t = parent.predicate("fhir:"+parentType+'.'+name); 8244 } 8245 composeBackboneElement(t, "parameter", name, element, index); 8246 if (element.hasNameElement()) 8247 composeCode(t, "ModuleDefinition", "name", element.getNameElement(), -1); 8248 if (element.hasUseElement()) 8249 composeCode(t, "ModuleDefinition", "use", element.getUseElement(), -1); 8250 if (element.hasDocumentationElement()) 8251 composeString(t, "ModuleDefinition", "documentation", element.getDocumentationElement(), -1); 8252 if (element.hasTypeElement()) 8253 composeCode(t, "ModuleDefinition", "type", element.getTypeElement(), -1); 8254 if (element.hasProfile()) 8255 composeReference(t, "ModuleDefinition", "profile", element.getProfile(), -1); 8256 } 8257 8258 protected void composeModuleDefinitionModuleDefinitionDataComponent(Complex parent, String parentType, String name, ModuleDefinition.ModuleDefinitionDataComponent element, int index) { 8259 if (element == null) 8260 return; 8261 Complex t; 8262 if (Utilities.noString(parentType)) 8263 t = parent; 8264 else { 8265 t = parent.predicate("fhir:"+parentType+'.'+name); 8266 } 8267 composeBackboneElement(t, "data", name, element, index); 8268 if (element.hasTypeElement()) 8269 composeCode(t, "ModuleDefinition", "type", element.getTypeElement(), -1); 8270 if (element.hasProfile()) 8271 composeReference(t, "ModuleDefinition", "profile", element.getProfile(), -1); 8272 for (int i = 0; i < element.getMustSupport().size(); i++) 8273 composeString(t, "ModuleDefinition", "mustSupport", element.getMustSupport().get(i), i); 8274 for (int i = 0; i < element.getCodeFilter().size(); i++) 8275 composeModuleDefinitionModuleDefinitionDataCodeFilterComponent(t, "ModuleDefinition", "codeFilter", element.getCodeFilter().get(i), i); 8276 for (int i = 0; i < element.getDateFilter().size(); i++) 8277 composeModuleDefinitionModuleDefinitionDataDateFilterComponent(t, "ModuleDefinition", "dateFilter", element.getDateFilter().get(i), i); 8278 } 8279 8280 protected void composeModuleDefinitionModuleDefinitionDataCodeFilterComponent(Complex parent, String parentType, String name, ModuleDefinition.ModuleDefinitionDataCodeFilterComponent element, int index) { 8281 if (element == null) 8282 return; 8283 Complex t; 8284 if (Utilities.noString(parentType)) 8285 t = parent; 8286 else { 8287 t = parent.predicate("fhir:"+parentType+'.'+name); 8288 } 8289 composeBackboneElement(t, "codeFilter", name, element, index); 8290 if (element.hasPathElement()) 8291 composeString(t, "ModuleDefinition", "path", element.getPathElement(), -1); 8292 if (element.hasValueSet()) 8293 composeType(t, "ModuleDefinition", "valueSet", element.getValueSet(), -1); 8294 for (int i = 0; i < element.getCodeableConcept().size(); i++) 8295 composeCodeableConcept(t, "ModuleDefinition", "codeableConcept", element.getCodeableConcept().get(i), i); 8296 } 8297 8298 protected void composeModuleDefinitionModuleDefinitionDataDateFilterComponent(Complex parent, String parentType, String name, ModuleDefinition.ModuleDefinitionDataDateFilterComponent element, int index) { 8299 if (element == null) 8300 return; 8301 Complex t; 8302 if (Utilities.noString(parentType)) 8303 t = parent; 8304 else { 8305 t = parent.predicate("fhir:"+parentType+'.'+name); 8306 } 8307 composeBackboneElement(t, "dateFilter", name, element, index); 8308 if (element.hasPathElement()) 8309 composeString(t, "ModuleDefinition", "path", element.getPathElement(), -1); 8310 if (element.hasValue()) 8311 composeType(t, "ModuleDefinition", "value", element.getValue(), -1); 8312 } 8313 8314 protected void composeNamingSystem(Complex parent, String parentType, String name, NamingSystem element, int index) { 8315 if (element == null) 8316 return; 8317 Complex t; 8318 if (Utilities.noString(parentType)) 8319 t = parent; 8320 else { 8321 t = parent.predicate("fhir:"+parentType+'.'+name); 8322 } 8323 composeDomainResource(t, "NamingSystem", name, element, index); 8324 if (element.hasNameElement()) 8325 composeString(t, "NamingSystem", "name", element.getNameElement(), -1); 8326 if (element.hasStatusElement()) 8327 composeEnum(t, "NamingSystem", "status", element.getStatusElement(), -1); 8328 if (element.hasKindElement()) 8329 composeEnum(t, "NamingSystem", "kind", element.getKindElement(), -1); 8330 if (element.hasDateElement()) 8331 composeDateTime(t, "NamingSystem", "date", element.getDateElement(), -1); 8332 if (element.hasPublisherElement()) 8333 composeString(t, "NamingSystem", "publisher", element.getPublisherElement(), -1); 8334 for (int i = 0; i < element.getContact().size(); i++) 8335 composeNamingSystemNamingSystemContactComponent(t, "NamingSystem", "contact", element.getContact().get(i), i); 8336 if (element.hasResponsibleElement()) 8337 composeString(t, "NamingSystem", "responsible", element.getResponsibleElement(), -1); 8338 if (element.hasType()) 8339 composeCodeableConcept(t, "NamingSystem", "type", element.getType(), -1); 8340 if (element.hasDescriptionElement()) 8341 composeString(t, "NamingSystem", "description", element.getDescriptionElement(), -1); 8342 for (int i = 0; i < element.getUseContext().size(); i++) 8343 composeCodeableConcept(t, "NamingSystem", "useContext", element.getUseContext().get(i), i); 8344 if (element.hasUsageElement()) 8345 composeString(t, "NamingSystem", "usage", element.getUsageElement(), -1); 8346 for (int i = 0; i < element.getUniqueId().size(); i++) 8347 composeNamingSystemNamingSystemUniqueIdComponent(t, "NamingSystem", "uniqueId", element.getUniqueId().get(i), i); 8348 if (element.hasReplacedBy()) 8349 composeReference(t, "NamingSystem", "replacedBy", element.getReplacedBy(), -1); 8350 } 8351 8352 protected void composeNamingSystemNamingSystemContactComponent(Complex parent, String parentType, String name, NamingSystem.NamingSystemContactComponent element, int index) { 8353 if (element == null) 8354 return; 8355 Complex t; 8356 if (Utilities.noString(parentType)) 8357 t = parent; 8358 else { 8359 t = parent.predicate("fhir:"+parentType+'.'+name); 8360 } 8361 composeBackboneElement(t, "contact", name, element, index); 8362 if (element.hasNameElement()) 8363 composeString(t, "NamingSystem", "name", element.getNameElement(), -1); 8364 for (int i = 0; i < element.getTelecom().size(); i++) 8365 composeContactPoint(t, "NamingSystem", "telecom", element.getTelecom().get(i), i); 8366 } 8367 8368 protected void composeNamingSystemNamingSystemUniqueIdComponent(Complex parent, String parentType, String name, NamingSystem.NamingSystemUniqueIdComponent element, int index) { 8369 if (element == null) 8370 return; 8371 Complex t; 8372 if (Utilities.noString(parentType)) 8373 t = parent; 8374 else { 8375 t = parent.predicate("fhir:"+parentType+'.'+name); 8376 } 8377 composeBackboneElement(t, "uniqueId", name, element, index); 8378 if (element.hasTypeElement()) 8379 composeEnum(t, "NamingSystem", "type", element.getTypeElement(), -1); 8380 if (element.hasValueElement()) 8381 composeString(t, "NamingSystem", "value", element.getValueElement(), -1); 8382 if (element.hasPreferredElement()) 8383 composeBoolean(t, "NamingSystem", "preferred", element.getPreferredElement(), -1); 8384 if (element.hasPeriod()) 8385 composePeriod(t, "NamingSystem", "period", element.getPeriod(), -1); 8386 } 8387 8388 protected void composeNutritionOrder(Complex parent, String parentType, String name, NutritionOrder element, int index) { 8389 if (element == null) 8390 return; 8391 Complex t; 8392 if (Utilities.noString(parentType)) 8393 t = parent; 8394 else { 8395 t = parent.predicate("fhir:"+parentType+'.'+name); 8396 } 8397 composeDomainResource(t, "NutritionOrder", name, element, index); 8398 for (int i = 0; i < element.getIdentifier().size(); i++) 8399 composeIdentifier(t, "NutritionOrder", "identifier", element.getIdentifier().get(i), i); 8400 if (element.hasStatusElement()) 8401 composeEnum(t, "NutritionOrder", "status", element.getStatusElement(), -1); 8402 if (element.hasPatient()) 8403 composeReference(t, "NutritionOrder", "patient", element.getPatient(), -1); 8404 if (element.hasEncounter()) 8405 composeReference(t, "NutritionOrder", "encounter", element.getEncounter(), -1); 8406 if (element.hasDateTimeElement()) 8407 composeDateTime(t, "NutritionOrder", "dateTime", element.getDateTimeElement(), -1); 8408 if (element.hasOrderer()) 8409 composeReference(t, "NutritionOrder", "orderer", element.getOrderer(), -1); 8410 for (int i = 0; i < element.getAllergyIntolerance().size(); i++) 8411 composeReference(t, "NutritionOrder", "allergyIntolerance", element.getAllergyIntolerance().get(i), i); 8412 for (int i = 0; i < element.getFoodPreferenceModifier().size(); i++) 8413 composeCodeableConcept(t, "NutritionOrder", "foodPreferenceModifier", element.getFoodPreferenceModifier().get(i), i); 8414 for (int i = 0; i < element.getExcludeFoodModifier().size(); i++) 8415 composeCodeableConcept(t, "NutritionOrder", "excludeFoodModifier", element.getExcludeFoodModifier().get(i), i); 8416 if (element.hasOralDiet()) 8417 composeNutritionOrderNutritionOrderOralDietComponent(t, "NutritionOrder", "oralDiet", element.getOralDiet(), -1); 8418 for (int i = 0; i < element.getSupplement().size(); i++) 8419 composeNutritionOrderNutritionOrderSupplementComponent(t, "NutritionOrder", "supplement", element.getSupplement().get(i), i); 8420 if (element.hasEnteralFormula()) 8421 composeNutritionOrderNutritionOrderEnteralFormulaComponent(t, "NutritionOrder", "enteralFormula", element.getEnteralFormula(), -1); 8422 } 8423 8424 protected void composeNutritionOrderNutritionOrderOralDietComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietComponent element, int index) { 8425 if (element == null) 8426 return; 8427 Complex t; 8428 if (Utilities.noString(parentType)) 8429 t = parent; 8430 else { 8431 t = parent.predicate("fhir:"+parentType+'.'+name); 8432 } 8433 composeBackboneElement(t, "oralDiet", name, element, index); 8434 for (int i = 0; i < element.getType().size(); i++) 8435 composeCodeableConcept(t, "NutritionOrder", "type", element.getType().get(i), i); 8436 for (int i = 0; i < element.getSchedule().size(); i++) 8437 composeTiming(t, "NutritionOrder", "schedule", element.getSchedule().get(i), i); 8438 for (int i = 0; i < element.getNutrient().size(); i++) 8439 composeNutritionOrderNutritionOrderOralDietNutrientComponent(t, "NutritionOrder", "nutrient", element.getNutrient().get(i), i); 8440 for (int i = 0; i < element.getTexture().size(); i++) 8441 composeNutritionOrderNutritionOrderOralDietTextureComponent(t, "NutritionOrder", "texture", element.getTexture().get(i), i); 8442 for (int i = 0; i < element.getFluidConsistencyType().size(); i++) 8443 composeCodeableConcept(t, "NutritionOrder", "fluidConsistencyType", element.getFluidConsistencyType().get(i), i); 8444 if (element.hasInstructionElement()) 8445 composeString(t, "NutritionOrder", "instruction", element.getInstructionElement(), -1); 8446 } 8447 8448 protected void composeNutritionOrderNutritionOrderOralDietNutrientComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietNutrientComponent element, int index) { 8449 if (element == null) 8450 return; 8451 Complex t; 8452 if (Utilities.noString(parentType)) 8453 t = parent; 8454 else { 8455 t = parent.predicate("fhir:"+parentType+'.'+name); 8456 } 8457 composeBackboneElement(t, "nutrient", name, element, index); 8458 if (element.hasModifier()) 8459 composeCodeableConcept(t, "NutritionOrder", "modifier", element.getModifier(), -1); 8460 if (element.hasAmount()) 8461 composeQuantity(t, "NutritionOrder", "amount", element.getAmount(), -1); 8462 } 8463 8464 protected void composeNutritionOrderNutritionOrderOralDietTextureComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderOralDietTextureComponent element, int index) { 8465 if (element == null) 8466 return; 8467 Complex t; 8468 if (Utilities.noString(parentType)) 8469 t = parent; 8470 else { 8471 t = parent.predicate("fhir:"+parentType+'.'+name); 8472 } 8473 composeBackboneElement(t, "texture", name, element, index); 8474 if (element.hasModifier()) 8475 composeCodeableConcept(t, "NutritionOrder", "modifier", element.getModifier(), -1); 8476 if (element.hasFoodType()) 8477 composeCodeableConcept(t, "NutritionOrder", "foodType", element.getFoodType(), -1); 8478 } 8479 8480 protected void composeNutritionOrderNutritionOrderSupplementComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderSupplementComponent element, int index) { 8481 if (element == null) 8482 return; 8483 Complex t; 8484 if (Utilities.noString(parentType)) 8485 t = parent; 8486 else { 8487 t = parent.predicate("fhir:"+parentType+'.'+name); 8488 } 8489 composeBackboneElement(t, "supplement", name, element, index); 8490 if (element.hasType()) 8491 composeCodeableConcept(t, "NutritionOrder", "type", element.getType(), -1); 8492 if (element.hasProductNameElement()) 8493 composeString(t, "NutritionOrder", "productName", element.getProductNameElement(), -1); 8494 for (int i = 0; i < element.getSchedule().size(); i++) 8495 composeTiming(t, "NutritionOrder", "schedule", element.getSchedule().get(i), i); 8496 if (element.hasQuantity()) 8497 composeQuantity(t, "NutritionOrder", "quantity", element.getQuantity(), -1); 8498 if (element.hasInstructionElement()) 8499 composeString(t, "NutritionOrder", "instruction", element.getInstructionElement(), -1); 8500 } 8501 8502 protected void composeNutritionOrderNutritionOrderEnteralFormulaComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaComponent element, int index) { 8503 if (element == null) 8504 return; 8505 Complex t; 8506 if (Utilities.noString(parentType)) 8507 t = parent; 8508 else { 8509 t = parent.predicate("fhir:"+parentType+'.'+name); 8510 } 8511 composeBackboneElement(t, "enteralFormula", name, element, index); 8512 if (element.hasBaseFormulaType()) 8513 composeCodeableConcept(t, "NutritionOrder", "baseFormulaType", element.getBaseFormulaType(), -1); 8514 if (element.hasBaseFormulaProductNameElement()) 8515 composeString(t, "NutritionOrder", "baseFormulaProductName", element.getBaseFormulaProductNameElement(), -1); 8516 if (element.hasAdditiveType()) 8517 composeCodeableConcept(t, "NutritionOrder", "additiveType", element.getAdditiveType(), -1); 8518 if (element.hasAdditiveProductNameElement()) 8519 composeString(t, "NutritionOrder", "additiveProductName", element.getAdditiveProductNameElement(), -1); 8520 if (element.hasCaloricDensity()) 8521 composeQuantity(t, "NutritionOrder", "caloricDensity", element.getCaloricDensity(), -1); 8522 if (element.hasRouteofAdministration()) 8523 composeCodeableConcept(t, "NutritionOrder", "routeofAdministration", element.getRouteofAdministration(), -1); 8524 for (int i = 0; i < element.getAdministration().size(); i++) 8525 composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(t, "NutritionOrder", "administration", element.getAdministration().get(i), i); 8526 if (element.hasMaxVolumeToDeliver()) 8527 composeQuantity(t, "NutritionOrder", "maxVolumeToDeliver", element.getMaxVolumeToDeliver(), -1); 8528 if (element.hasAdministrationInstructionElement()) 8529 composeString(t, "NutritionOrder", "administrationInstruction", element.getAdministrationInstructionElement(), -1); 8530 } 8531 8532 protected void composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(Complex parent, String parentType, String name, NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent element, int index) { 8533 if (element == null) 8534 return; 8535 Complex t; 8536 if (Utilities.noString(parentType)) 8537 t = parent; 8538 else { 8539 t = parent.predicate("fhir:"+parentType+'.'+name); 8540 } 8541 composeBackboneElement(t, "administration", name, element, index); 8542 if (element.hasSchedule()) 8543 composeTiming(t, "NutritionOrder", "schedule", element.getSchedule(), -1); 8544 if (element.hasQuantity()) 8545 composeQuantity(t, "NutritionOrder", "quantity", element.getQuantity(), -1); 8546 if (element.hasRate()) 8547 composeType(t, "NutritionOrder", "rate", element.getRate(), -1); 8548 } 8549 8550 protected void composeObservation(Complex parent, String parentType, String name, Observation element, int index) { 8551 if (element == null) 8552 return; 8553 Complex t; 8554 if (Utilities.noString(parentType)) 8555 t = parent; 8556 else { 8557 t = parent.predicate("fhir:"+parentType+'.'+name); 8558 } 8559 composeDomainResource(t, "Observation", name, element, index); 8560 for (int i = 0; i < element.getIdentifier().size(); i++) 8561 composeIdentifier(t, "Observation", "identifier", element.getIdentifier().get(i), i); 8562 if (element.hasStatusElement()) 8563 composeEnum(t, "Observation", "status", element.getStatusElement(), -1); 8564 if (element.hasCategory()) 8565 composeCodeableConcept(t, "Observation", "category", element.getCategory(), -1); 8566 if (element.hasCode()) 8567 composeCodeableConcept(t, "Observation", "code", element.getCode(), -1); 8568 if (element.hasSubject()) 8569 composeReference(t, "Observation", "subject", element.getSubject(), -1); 8570 if (element.hasEncounter()) 8571 composeReference(t, "Observation", "encounter", element.getEncounter(), -1); 8572 if (element.hasEffective()) 8573 composeType(t, "Observation", "effective", element.getEffective(), -1); 8574 if (element.hasIssuedElement()) 8575 composeInstant(t, "Observation", "issued", element.getIssuedElement(), -1); 8576 for (int i = 0; i < element.getPerformer().size(); i++) 8577 composeReference(t, "Observation", "performer", element.getPerformer().get(i), i); 8578 if (element.hasValue()) 8579 composeType(t, "Observation", "value", element.getValue(), -1); 8580 if (element.hasDataAbsentReason()) 8581 composeCodeableConcept(t, "Observation", "dataAbsentReason", element.getDataAbsentReason(), -1); 8582 if (element.hasInterpretation()) 8583 composeCodeableConcept(t, "Observation", "interpretation", element.getInterpretation(), -1); 8584 if (element.hasCommentElement()) 8585 composeString(t, "Observation", "comment", element.getCommentElement(), -1); 8586 if (element.hasBodySite()) 8587 composeCodeableConcept(t, "Observation", "bodySite", element.getBodySite(), -1); 8588 if (element.hasMethod()) 8589 composeCodeableConcept(t, "Observation", "method", element.getMethod(), -1); 8590 if (element.hasSpecimen()) 8591 composeReference(t, "Observation", "specimen", element.getSpecimen(), -1); 8592 if (element.hasDevice()) 8593 composeReference(t, "Observation", "device", element.getDevice(), -1); 8594 for (int i = 0; i < element.getReferenceRange().size(); i++) 8595 composeObservationObservationReferenceRangeComponent(t, "Observation", "referenceRange", element.getReferenceRange().get(i), i); 8596 for (int i = 0; i < element.getRelated().size(); i++) 8597 composeObservationObservationRelatedComponent(t, "Observation", "related", element.getRelated().get(i), i); 8598 for (int i = 0; i < element.getComponent().size(); i++) 8599 composeObservationObservationComponentComponent(t, "Observation", "component", element.getComponent().get(i), i); 8600 } 8601 8602 protected void composeObservationObservationReferenceRangeComponent(Complex parent, String parentType, String name, Observation.ObservationReferenceRangeComponent element, int index) { 8603 if (element == null) 8604 return; 8605 Complex t; 8606 if (Utilities.noString(parentType)) 8607 t = parent; 8608 else { 8609 t = parent.predicate("fhir:"+parentType+'.'+name); 8610 } 8611 composeBackboneElement(t, "referenceRange", name, element, index); 8612 if (element.hasLow()) 8613 composeQuantity(t, "Observation", "low", element.getLow(), -1); 8614 if (element.hasHigh()) 8615 composeQuantity(t, "Observation", "high", element.getHigh(), -1); 8616 if (element.hasMeaning()) 8617 composeCodeableConcept(t, "Observation", "meaning", element.getMeaning(), -1); 8618 if (element.hasAge()) 8619 composeRange(t, "Observation", "age", element.getAge(), -1); 8620 if (element.hasTextElement()) 8621 composeString(t, "Observation", "text", element.getTextElement(), -1); 8622 } 8623 8624 protected void composeObservationObservationRelatedComponent(Complex parent, String parentType, String name, Observation.ObservationRelatedComponent element, int index) { 8625 if (element == null) 8626 return; 8627 Complex t; 8628 if (Utilities.noString(parentType)) 8629 t = parent; 8630 else { 8631 t = parent.predicate("fhir:"+parentType+'.'+name); 8632 } 8633 composeBackboneElement(t, "related", name, element, index); 8634 if (element.hasTypeElement()) 8635 composeEnum(t, "Observation", "type", element.getTypeElement(), -1); 8636 if (element.hasTarget()) 8637 composeReference(t, "Observation", "target", element.getTarget(), -1); 8638 } 8639 8640 protected void composeObservationObservationComponentComponent(Complex parent, String parentType, String name, Observation.ObservationComponentComponent element, int index) { 8641 if (element == null) 8642 return; 8643 Complex t; 8644 if (Utilities.noString(parentType)) 8645 t = parent; 8646 else { 8647 t = parent.predicate("fhir:"+parentType+'.'+name); 8648 } 8649 composeBackboneElement(t, "component", name, element, index); 8650 if (element.hasCode()) 8651 composeCodeableConcept(t, "Observation", "code", element.getCode(), -1); 8652 if (element.hasValue()) 8653 composeType(t, "Observation", "value", element.getValue(), -1); 8654 if (element.hasDataAbsentReason()) 8655 composeCodeableConcept(t, "Observation", "dataAbsentReason", element.getDataAbsentReason(), -1); 8656 for (int i = 0; i < element.getReferenceRange().size(); i++) 8657 composeObservationObservationReferenceRangeComponent(t, "Observation", "referenceRange", element.getReferenceRange().get(i), i); 8658 } 8659 8660 protected void composeOperationDefinition(Complex parent, String parentType, String name, OperationDefinition element, int index) { 8661 if (element == null) 8662 return; 8663 Complex t; 8664 if (Utilities.noString(parentType)) 8665 t = parent; 8666 else { 8667 t = parent.predicate("fhir:"+parentType+'.'+name); 8668 } 8669 composeDomainResource(t, "OperationDefinition", name, element, index); 8670 if (element.hasUrlElement()) 8671 composeUri(t, "OperationDefinition", "url", element.getUrlElement(), -1); 8672 if (element.hasVersionElement()) 8673 composeString(t, "OperationDefinition", "version", element.getVersionElement(), -1); 8674 if (element.hasNameElement()) 8675 composeString(t, "OperationDefinition", "name", element.getNameElement(), -1); 8676 if (element.hasStatusElement()) 8677 composeEnum(t, "OperationDefinition", "status", element.getStatusElement(), -1); 8678 if (element.hasKindElement()) 8679 composeEnum(t, "OperationDefinition", "kind", element.getKindElement(), -1); 8680 if (element.hasExperimentalElement()) 8681 composeBoolean(t, "OperationDefinition", "experimental", element.getExperimentalElement(), -1); 8682 if (element.hasDateElement()) 8683 composeDateTime(t, "OperationDefinition", "date", element.getDateElement(), -1); 8684 if (element.hasPublisherElement()) 8685 composeString(t, "OperationDefinition", "publisher", element.getPublisherElement(), -1); 8686 for (int i = 0; i < element.getContact().size(); i++) 8687 composeOperationDefinitionOperationDefinitionContactComponent(t, "OperationDefinition", "contact", element.getContact().get(i), i); 8688 if (element.hasDescriptionElement()) 8689 composeString(t, "OperationDefinition", "description", element.getDescriptionElement(), -1); 8690 for (int i = 0; i < element.getUseContext().size(); i++) 8691 composeCodeableConcept(t, "OperationDefinition", "useContext", element.getUseContext().get(i), i); 8692 if (element.hasRequirementsElement()) 8693 composeString(t, "OperationDefinition", "requirements", element.getRequirementsElement(), -1); 8694 if (element.hasIdempotentElement()) 8695 composeBoolean(t, "OperationDefinition", "idempotent", element.getIdempotentElement(), -1); 8696 if (element.hasCodeElement()) 8697 composeCode(t, "OperationDefinition", "code", element.getCodeElement(), -1); 8698 if (element.hasCommentElement()) 8699 composeString(t, "OperationDefinition", "comment", element.getCommentElement(), -1); 8700 if (element.hasBase()) 8701 composeReference(t, "OperationDefinition", "base", element.getBase(), -1); 8702 if (element.hasSystemElement()) 8703 composeBoolean(t, "OperationDefinition", "system", element.getSystemElement(), -1); 8704 for (int i = 0; i < element.getType().size(); i++) 8705 composeCode(t, "OperationDefinition", "type", element.getType().get(i), i); 8706 if (element.hasInstanceElement()) 8707 composeBoolean(t, "OperationDefinition", "instance", element.getInstanceElement(), -1); 8708 for (int i = 0; i < element.getParameter().size(); i++) 8709 composeOperationDefinitionOperationDefinitionParameterComponent(t, "OperationDefinition", "parameter", element.getParameter().get(i), i); 8710 } 8711 8712 protected void composeOperationDefinitionOperationDefinitionContactComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionContactComponent element, int index) { 8713 if (element == null) 8714 return; 8715 Complex t; 8716 if (Utilities.noString(parentType)) 8717 t = parent; 8718 else { 8719 t = parent.predicate("fhir:"+parentType+'.'+name); 8720 } 8721 composeBackboneElement(t, "contact", name, element, index); 8722 if (element.hasNameElement()) 8723 composeString(t, "OperationDefinition", "name", element.getNameElement(), -1); 8724 for (int i = 0; i < element.getTelecom().size(); i++) 8725 composeContactPoint(t, "OperationDefinition", "telecom", element.getTelecom().get(i), i); 8726 } 8727 8728 protected void composeOperationDefinitionOperationDefinitionParameterComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterComponent element, int index) { 8729 if (element == null) 8730 return; 8731 Complex t; 8732 if (Utilities.noString(parentType)) 8733 t = parent; 8734 else { 8735 t = parent.predicate("fhir:"+parentType+'.'+name); 8736 } 8737 composeBackboneElement(t, "parameter", name, element, index); 8738 if (element.hasNameElement()) 8739 composeCode(t, "OperationDefinition", "name", element.getNameElement(), -1); 8740 if (element.hasUseElement()) 8741 composeEnum(t, "OperationDefinition", "use", element.getUseElement(), -1); 8742 if (element.hasMinElement()) 8743 composeInteger(t, "OperationDefinition", "min", element.getMinElement(), -1); 8744 if (element.hasMaxElement()) 8745 composeString(t, "OperationDefinition", "max", element.getMaxElement(), -1); 8746 if (element.hasDocumentationElement()) 8747 composeString(t, "OperationDefinition", "documentation", element.getDocumentationElement(), -1); 8748 if (element.hasTypeElement()) 8749 composeCode(t, "OperationDefinition", "type", element.getTypeElement(), -1); 8750 if (element.hasSearchTypeElement()) 8751 composeEnum(t, "OperationDefinition", "searchType", element.getSearchTypeElement(), -1); 8752 if (element.hasProfile()) 8753 composeReference(t, "OperationDefinition", "profile", element.getProfile(), -1); 8754 if (element.hasBinding()) 8755 composeOperationDefinitionOperationDefinitionParameterBindingComponent(t, "OperationDefinition", "binding", element.getBinding(), -1); 8756 for (int i = 0; i < element.getPart().size(); i++) 8757 composeOperationDefinitionOperationDefinitionParameterComponent(t, "OperationDefinition", "part", element.getPart().get(i), i); 8758 } 8759 8760 protected void composeOperationDefinitionOperationDefinitionParameterBindingComponent(Complex parent, String parentType, String name, OperationDefinition.OperationDefinitionParameterBindingComponent element, int index) { 8761 if (element == null) 8762 return; 8763 Complex t; 8764 if (Utilities.noString(parentType)) 8765 t = parent; 8766 else { 8767 t = parent.predicate("fhir:"+parentType+'.'+name); 8768 } 8769 composeBackboneElement(t, "binding", name, element, index); 8770 if (element.hasStrengthElement()) 8771 composeEnum(t, "OperationDefinition", "strength", element.getStrengthElement(), -1); 8772 if (element.hasValueSet()) 8773 composeType(t, "OperationDefinition", "valueSet", element.getValueSet(), -1); 8774 } 8775 8776 protected void composeOperationOutcome(Complex parent, String parentType, String name, OperationOutcome element, int index) { 8777 if (element == null) 8778 return; 8779 Complex t; 8780 if (Utilities.noString(parentType)) 8781 t = parent; 8782 else { 8783 t = parent.predicate("fhir:"+parentType+'.'+name); 8784 } 8785 composeDomainResource(t, "OperationOutcome", name, element, index); 8786 for (int i = 0; i < element.getIssue().size(); i++) 8787 composeOperationOutcomeOperationOutcomeIssueComponent(t, "OperationOutcome", "issue", element.getIssue().get(i), i); 8788 } 8789 8790 protected void composeOperationOutcomeOperationOutcomeIssueComponent(Complex parent, String parentType, String name, OperationOutcome.OperationOutcomeIssueComponent element, int index) { 8791 if (element == null) 8792 return; 8793 Complex t; 8794 if (Utilities.noString(parentType)) 8795 t = parent; 8796 else { 8797 t = parent.predicate("fhir:"+parentType+'.'+name); 8798 } 8799 composeBackboneElement(t, "issue", name, element, index); 8800 if (element.hasSeverityElement()) 8801 composeEnum(t, "OperationOutcome", "severity", element.getSeverityElement(), -1); 8802 if (element.hasCodeElement()) 8803 composeEnum(t, "OperationOutcome", "code", element.getCodeElement(), -1); 8804 if (element.hasDetails()) 8805 composeCodeableConcept(t, "OperationOutcome", "details", element.getDetails(), -1); 8806 if (element.hasDiagnosticsElement()) 8807 composeString(t, "OperationOutcome", "diagnostics", element.getDiagnosticsElement(), -1); 8808 for (int i = 0; i < element.getLocation().size(); i++) 8809 composeString(t, "OperationOutcome", "location", element.getLocation().get(i), i); 8810 for (int i = 0; i < element.getExpression().size(); i++) 8811 composeString(t, "OperationOutcome", "expression", element.getExpression().get(i), i); 8812 } 8813 8814 protected void composeOrder(Complex parent, String parentType, String name, Order element, int index) { 8815 if (element == null) 8816 return; 8817 Complex t; 8818 if (Utilities.noString(parentType)) 8819 t = parent; 8820 else { 8821 t = parent.predicate("fhir:"+parentType+'.'+name); 8822 } 8823 composeDomainResource(t, "Order", name, element, index); 8824 for (int i = 0; i < element.getIdentifier().size(); i++) 8825 composeIdentifier(t, "Order", "identifier", element.getIdentifier().get(i), i); 8826 if (element.hasDateElement()) 8827 composeDateTime(t, "Order", "date", element.getDateElement(), -1); 8828 if (element.hasSubject()) 8829 composeReference(t, "Order", "subject", element.getSubject(), -1); 8830 if (element.hasSource()) 8831 composeReference(t, "Order", "source", element.getSource(), -1); 8832 if (element.hasTarget()) 8833 composeReference(t, "Order", "target", element.getTarget(), -1); 8834 if (element.hasReason()) 8835 composeType(t, "Order", "reason", element.getReason(), -1); 8836 if (element.hasWhen()) 8837 composeOrderOrderWhenComponent(t, "Order", "when", element.getWhen(), -1); 8838 for (int i = 0; i < element.getDetail().size(); i++) 8839 composeReference(t, "Order", "detail", element.getDetail().get(i), i); 8840 } 8841 8842 protected void composeOrderOrderWhenComponent(Complex parent, String parentType, String name, Order.OrderWhenComponent element, int index) { 8843 if (element == null) 8844 return; 8845 Complex t; 8846 if (Utilities.noString(parentType)) 8847 t = parent; 8848 else { 8849 t = parent.predicate("fhir:"+parentType+'.'+name); 8850 } 8851 composeBackboneElement(t, "when", name, element, index); 8852 if (element.hasCode()) 8853 composeCodeableConcept(t, "Order", "code", element.getCode(), -1); 8854 if (element.hasSchedule()) 8855 composeTiming(t, "Order", "schedule", element.getSchedule(), -1); 8856 } 8857 8858 protected void composeOrderResponse(Complex parent, String parentType, String name, OrderResponse element, int index) { 8859 if (element == null) 8860 return; 8861 Complex t; 8862 if (Utilities.noString(parentType)) 8863 t = parent; 8864 else { 8865 t = parent.predicate("fhir:"+parentType+'.'+name); 8866 } 8867 composeDomainResource(t, "OrderResponse", name, element, index); 8868 for (int i = 0; i < element.getIdentifier().size(); i++) 8869 composeIdentifier(t, "OrderResponse", "identifier", element.getIdentifier().get(i), i); 8870 if (element.hasRequest()) 8871 composeReference(t, "OrderResponse", "request", element.getRequest(), -1); 8872 if (element.hasDateElement()) 8873 composeDateTime(t, "OrderResponse", "date", element.getDateElement(), -1); 8874 if (element.hasWho()) 8875 composeReference(t, "OrderResponse", "who", element.getWho(), -1); 8876 if (element.hasOrderStatusElement()) 8877 composeEnum(t, "OrderResponse", "orderStatus", element.getOrderStatusElement(), -1); 8878 if (element.hasDescriptionElement()) 8879 composeString(t, "OrderResponse", "description", element.getDescriptionElement(), -1); 8880 for (int i = 0; i < element.getFulfillment().size(); i++) 8881 composeReference(t, "OrderResponse", "fulfillment", element.getFulfillment().get(i), i); 8882 } 8883 8884 protected void composeOrderSet(Complex parent, String parentType, String name, OrderSet element, int index) { 8885 if (element == null) 8886 return; 8887 Complex t; 8888 if (Utilities.noString(parentType)) 8889 t = parent; 8890 else { 8891 t = parent.predicate("fhir:"+parentType+'.'+name); 8892 } 8893 composeDomainResource(t, "OrderSet", name, element, index); 8894 if (element.hasModuleMetadata()) 8895 composeModuleMetadata(t, "OrderSet", "moduleMetadata", element.getModuleMetadata(), -1); 8896 for (int i = 0; i < element.getLibrary().size(); i++) 8897 composeReference(t, "OrderSet", "library", element.getLibrary().get(i), i); 8898 for (int i = 0; i < element.getAction().size(); i++) 8899 composeActionDefinition(t, "OrderSet", "action", element.getAction().get(i), i); 8900 } 8901 8902 protected void composeOrganization(Complex parent, String parentType, String name, Organization element, int index) { 8903 if (element == null) 8904 return; 8905 Complex t; 8906 if (Utilities.noString(parentType)) 8907 t = parent; 8908 else { 8909 t = parent.predicate("fhir:"+parentType+'.'+name); 8910 } 8911 composeDomainResource(t, "Organization", name, element, index); 8912 for (int i = 0; i < element.getIdentifier().size(); i++) 8913 composeIdentifier(t, "Organization", "identifier", element.getIdentifier().get(i), i); 8914 if (element.hasActiveElement()) 8915 composeBoolean(t, "Organization", "active", element.getActiveElement(), -1); 8916 if (element.hasType()) 8917 composeCodeableConcept(t, "Organization", "type", element.getType(), -1); 8918 if (element.hasNameElement()) 8919 composeString(t, "Organization", "name", element.getNameElement(), -1); 8920 for (int i = 0; i < element.getTelecom().size(); i++) 8921 composeContactPoint(t, "Organization", "telecom", element.getTelecom().get(i), i); 8922 for (int i = 0; i < element.getAddress().size(); i++) 8923 composeAddress(t, "Organization", "address", element.getAddress().get(i), i); 8924 if (element.hasPartOf()) 8925 composeReference(t, "Organization", "partOf", element.getPartOf(), -1); 8926 for (int i = 0; i < element.getContact().size(); i++) 8927 composeOrganizationOrganizationContactComponent(t, "Organization", "contact", element.getContact().get(i), i); 8928 } 8929 8930 protected void composeOrganizationOrganizationContactComponent(Complex parent, String parentType, String name, Organization.OrganizationContactComponent element, int index) { 8931 if (element == null) 8932 return; 8933 Complex t; 8934 if (Utilities.noString(parentType)) 8935 t = parent; 8936 else { 8937 t = parent.predicate("fhir:"+parentType+'.'+name); 8938 } 8939 composeBackboneElement(t, "contact", name, element, index); 8940 if (element.hasPurpose()) 8941 composeCodeableConcept(t, "Organization", "purpose", element.getPurpose(), -1); 8942 if (element.hasName()) 8943 composeHumanName(t, "Organization", "name", element.getName(), -1); 8944 for (int i = 0; i < element.getTelecom().size(); i++) 8945 composeContactPoint(t, "Organization", "telecom", element.getTelecom().get(i), i); 8946 if (element.hasAddress()) 8947 composeAddress(t, "Organization", "address", element.getAddress(), -1); 8948 } 8949 8950 protected void composePatient(Complex parent, String parentType, String name, Patient element, int index) { 8951 if (element == null) 8952 return; 8953 Complex t; 8954 if (Utilities.noString(parentType)) 8955 t = parent; 8956 else { 8957 t = parent.predicate("fhir:"+parentType+'.'+name); 8958 } 8959 composeDomainResource(t, "Patient", name, element, index); 8960 for (int i = 0; i < element.getIdentifier().size(); i++) 8961 composeIdentifier(t, "Patient", "identifier", element.getIdentifier().get(i), i); 8962 if (element.hasActiveElement()) 8963 composeBoolean(t, "Patient", "active", element.getActiveElement(), -1); 8964 for (int i = 0; i < element.getName().size(); i++) 8965 composeHumanName(t, "Patient", "name", element.getName().get(i), i); 8966 for (int i = 0; i < element.getTelecom().size(); i++) 8967 composeContactPoint(t, "Patient", "telecom", element.getTelecom().get(i), i); 8968 if (element.hasGenderElement()) 8969 composeEnum(t, "Patient", "gender", element.getGenderElement(), -1); 8970 if (element.hasBirthDateElement()) 8971 composeDate(t, "Patient", "birthDate", element.getBirthDateElement(), -1); 8972 if (element.hasDeceased()) 8973 composeType(t, "Patient", "deceased", element.getDeceased(), -1); 8974 for (int i = 0; i < element.getAddress().size(); i++) 8975 composeAddress(t, "Patient", "address", element.getAddress().get(i), i); 8976 if (element.hasMaritalStatus()) 8977 composeCodeableConcept(t, "Patient", "maritalStatus", element.getMaritalStatus(), -1); 8978 if (element.hasMultipleBirth()) 8979 composeType(t, "Patient", "multipleBirth", element.getMultipleBirth(), -1); 8980 for (int i = 0; i < element.getPhoto().size(); i++) 8981 composeAttachment(t, "Patient", "photo", element.getPhoto().get(i), i); 8982 for (int i = 0; i < element.getContact().size(); i++) 8983 composePatientContactComponent(t, "Patient", "contact", element.getContact().get(i), i); 8984 if (element.hasAnimal()) 8985 composePatientAnimalComponent(t, "Patient", "animal", element.getAnimal(), -1); 8986 for (int i = 0; i < element.getCommunication().size(); i++) 8987 composePatientPatientCommunicationComponent(t, "Patient", "communication", element.getCommunication().get(i), i); 8988 for (int i = 0; i < element.getCareProvider().size(); i++) 8989 composeReference(t, "Patient", "careProvider", element.getCareProvider().get(i), i); 8990 if (element.hasManagingOrganization()) 8991 composeReference(t, "Patient", "managingOrganization", element.getManagingOrganization(), -1); 8992 for (int i = 0; i < element.getLink().size(); i++) 8993 composePatientPatientLinkComponent(t, "Patient", "link", element.getLink().get(i), i); 8994 } 8995 8996 protected void composePatientContactComponent(Complex parent, String parentType, String name, Patient.ContactComponent element, int index) { 8997 if (element == null) 8998 return; 8999 Complex t; 9000 if (Utilities.noString(parentType)) 9001 t = parent; 9002 else { 9003 t = parent.predicate("fhir:"+parentType+'.'+name); 9004 } 9005 composeBackboneElement(t, "contact", name, element, index); 9006 for (int i = 0; i < element.getRelationship().size(); i++) 9007 composeCodeableConcept(t, "Patient", "relationship", element.getRelationship().get(i), i); 9008 if (element.hasName()) 9009 composeHumanName(t, "Patient", "name", element.getName(), -1); 9010 for (int i = 0; i < element.getTelecom().size(); i++) 9011 composeContactPoint(t, "Patient", "telecom", element.getTelecom().get(i), i); 9012 if (element.hasAddress()) 9013 composeAddress(t, "Patient", "address", element.getAddress(), -1); 9014 if (element.hasGenderElement()) 9015 composeEnum(t, "Patient", "gender", element.getGenderElement(), -1); 9016 if (element.hasOrganization()) 9017 composeReference(t, "Patient", "organization", element.getOrganization(), -1); 9018 if (element.hasPeriod()) 9019 composePeriod(t, "Patient", "period", element.getPeriod(), -1); 9020 } 9021 9022 protected void composePatientAnimalComponent(Complex parent, String parentType, String name, Patient.AnimalComponent element, int index) { 9023 if (element == null) 9024 return; 9025 Complex t; 9026 if (Utilities.noString(parentType)) 9027 t = parent; 9028 else { 9029 t = parent.predicate("fhir:"+parentType+'.'+name); 9030 } 9031 composeBackboneElement(t, "animal", name, element, index); 9032 if (element.hasSpecies()) 9033 composeCodeableConcept(t, "Patient", "species", element.getSpecies(), -1); 9034 if (element.hasBreed()) 9035 composeCodeableConcept(t, "Patient", "breed", element.getBreed(), -1); 9036 if (element.hasGenderStatus()) 9037 composeCodeableConcept(t, "Patient", "genderStatus", element.getGenderStatus(), -1); 9038 } 9039 9040 protected void composePatientPatientCommunicationComponent(Complex parent, String parentType, String name, Patient.PatientCommunicationComponent element, int index) { 9041 if (element == null) 9042 return; 9043 Complex t; 9044 if (Utilities.noString(parentType)) 9045 t = parent; 9046 else { 9047 t = parent.predicate("fhir:"+parentType+'.'+name); 9048 } 9049 composeBackboneElement(t, "communication", name, element, index); 9050 if (element.hasLanguage()) 9051 composeCodeableConcept(t, "Patient", "language", element.getLanguage(), -1); 9052 if (element.hasPreferredElement()) 9053 composeBoolean(t, "Patient", "preferred", element.getPreferredElement(), -1); 9054 } 9055 9056 protected void composePatientPatientLinkComponent(Complex parent, String parentType, String name, Patient.PatientLinkComponent element, int index) { 9057 if (element == null) 9058 return; 9059 Complex t; 9060 if (Utilities.noString(parentType)) 9061 t = parent; 9062 else { 9063 t = parent.predicate("fhir:"+parentType+'.'+name); 9064 } 9065 composeBackboneElement(t, "link", name, element, index); 9066 if (element.hasOther()) 9067 composeReference(t, "Patient", "other", element.getOther(), -1); 9068 if (element.hasTypeElement()) 9069 composeEnum(t, "Patient", "type", element.getTypeElement(), -1); 9070 } 9071 9072 protected void composePaymentNotice(Complex parent, String parentType, String name, PaymentNotice element, int index) { 9073 if (element == null) 9074 return; 9075 Complex t; 9076 if (Utilities.noString(parentType)) 9077 t = parent; 9078 else { 9079 t = parent.predicate("fhir:"+parentType+'.'+name); 9080 } 9081 composeDomainResource(t, "PaymentNotice", name, element, index); 9082 for (int i = 0; i < element.getIdentifier().size(); i++) 9083 composeIdentifier(t, "PaymentNotice", "identifier", element.getIdentifier().get(i), i); 9084 if (element.hasRuleset()) 9085 composeCoding(t, "PaymentNotice", "ruleset", element.getRuleset(), -1); 9086 if (element.hasOriginalRuleset()) 9087 composeCoding(t, "PaymentNotice", "originalRuleset", element.getOriginalRuleset(), -1); 9088 if (element.hasCreatedElement()) 9089 composeDateTime(t, "PaymentNotice", "created", element.getCreatedElement(), -1); 9090 if (element.hasTarget()) 9091 composeType(t, "PaymentNotice", "target", element.getTarget(), -1); 9092 if (element.hasProvider()) 9093 composeType(t, "PaymentNotice", "provider", element.getProvider(), -1); 9094 if (element.hasOrganization()) 9095 composeType(t, "PaymentNotice", "organization", element.getOrganization(), -1); 9096 if (element.hasRequest()) 9097 composeType(t, "PaymentNotice", "request", element.getRequest(), -1); 9098 if (element.hasResponse()) 9099 composeType(t, "PaymentNotice", "response", element.getResponse(), -1); 9100 if (element.hasPaymentStatus()) 9101 composeCoding(t, "PaymentNotice", "paymentStatus", element.getPaymentStatus(), -1); 9102 if (element.hasStatusDateElement()) 9103 composeDate(t, "PaymentNotice", "statusDate", element.getStatusDateElement(), -1); 9104 } 9105 9106 protected void composePaymentReconciliation(Complex parent, String parentType, String name, PaymentReconciliation element, int index) { 9107 if (element == null) 9108 return; 9109 Complex t; 9110 if (Utilities.noString(parentType)) 9111 t = parent; 9112 else { 9113 t = parent.predicate("fhir:"+parentType+'.'+name); 9114 } 9115 composeDomainResource(t, "PaymentReconciliation", name, element, index); 9116 for (int i = 0; i < element.getIdentifier().size(); i++) 9117 composeIdentifier(t, "PaymentReconciliation", "identifier", element.getIdentifier().get(i), i); 9118 if (element.hasRequest()) 9119 composeType(t, "PaymentReconciliation", "request", element.getRequest(), -1); 9120 if (element.hasOutcomeElement()) 9121 composeEnum(t, "PaymentReconciliation", "outcome", element.getOutcomeElement(), -1); 9122 if (element.hasDispositionElement()) 9123 composeString(t, "PaymentReconciliation", "disposition", element.getDispositionElement(), -1); 9124 if (element.hasRuleset()) 9125 composeCoding(t, "PaymentReconciliation", "ruleset", element.getRuleset(), -1); 9126 if (element.hasOriginalRuleset()) 9127 composeCoding(t, "PaymentReconciliation", "originalRuleset", element.getOriginalRuleset(), -1); 9128 if (element.hasCreatedElement()) 9129 composeDateTime(t, "PaymentReconciliation", "created", element.getCreatedElement(), -1); 9130 if (element.hasPeriod()) 9131 composePeriod(t, "PaymentReconciliation", "period", element.getPeriod(), -1); 9132 if (element.hasOrganization()) 9133 composeType(t, "PaymentReconciliation", "organization", element.getOrganization(), -1); 9134 if (element.hasRequestProvider()) 9135 composeType(t, "PaymentReconciliation", "requestProvider", element.getRequestProvider(), -1); 9136 if (element.hasRequestOrganization()) 9137 composeType(t, "PaymentReconciliation", "requestOrganization", element.getRequestOrganization(), -1); 9138 for (int i = 0; i < element.getDetail().size(); i++) 9139 composePaymentReconciliationDetailsComponent(t, "PaymentReconciliation", "detail", element.getDetail().get(i), i); 9140 if (element.hasForm()) 9141 composeCoding(t, "PaymentReconciliation", "form", element.getForm(), -1); 9142 if (element.hasTotal()) 9143 composeQuantity(t, "PaymentReconciliation", "total", element.getTotal(), -1); 9144 for (int i = 0; i < element.getNote().size(); i++) 9145 composePaymentReconciliationNotesComponent(t, "PaymentReconciliation", "note", element.getNote().get(i), i); 9146 } 9147 9148 protected void composePaymentReconciliationDetailsComponent(Complex parent, String parentType, String name, PaymentReconciliation.DetailsComponent element, int index) { 9149 if (element == null) 9150 return; 9151 Complex t; 9152 if (Utilities.noString(parentType)) 9153 t = parent; 9154 else { 9155 t = parent.predicate("fhir:"+parentType+'.'+name); 9156 } 9157 composeBackboneElement(t, "detail", name, element, index); 9158 if (element.hasType()) 9159 composeCoding(t, "PaymentReconciliation", "type", element.getType(), -1); 9160 if (element.hasRequest()) 9161 composeType(t, "PaymentReconciliation", "request", element.getRequest(), -1); 9162 if (element.hasResponce()) 9163 composeType(t, "PaymentReconciliation", "responce", element.getResponce(), -1); 9164 if (element.hasSubmitter()) 9165 composeType(t, "PaymentReconciliation", "submitter", element.getSubmitter(), -1); 9166 if (element.hasPayee()) 9167 composeType(t, "PaymentReconciliation", "payee", element.getPayee(), -1); 9168 if (element.hasDateElement()) 9169 composeDate(t, "PaymentReconciliation", "date", element.getDateElement(), -1); 9170 if (element.hasAmount()) 9171 composeQuantity(t, "PaymentReconciliation", "amount", element.getAmount(), -1); 9172 } 9173 9174 protected void composePaymentReconciliationNotesComponent(Complex parent, String parentType, String name, PaymentReconciliation.NotesComponent element, int index) { 9175 if (element == null) 9176 return; 9177 Complex t; 9178 if (Utilities.noString(parentType)) 9179 t = parent; 9180 else { 9181 t = parent.predicate("fhir:"+parentType+'.'+name); 9182 } 9183 composeBackboneElement(t, "note", name, element, index); 9184 if (element.hasType()) 9185 composeCoding(t, "PaymentReconciliation", "type", element.getType(), -1); 9186 if (element.hasTextElement()) 9187 composeString(t, "PaymentReconciliation", "text", element.getTextElement(), -1); 9188 } 9189 9190 protected void composePerson(Complex parent, String parentType, String name, Person element, int index) { 9191 if (element == null) 9192 return; 9193 Complex t; 9194 if (Utilities.noString(parentType)) 9195 t = parent; 9196 else { 9197 t = parent.predicate("fhir:"+parentType+'.'+name); 9198 } 9199 composeDomainResource(t, "Person", name, element, index); 9200 for (int i = 0; i < element.getIdentifier().size(); i++) 9201 composeIdentifier(t, "Person", "identifier", element.getIdentifier().get(i), i); 9202 for (int i = 0; i < element.getName().size(); i++) 9203 composeHumanName(t, "Person", "name", element.getName().get(i), i); 9204 for (int i = 0; i < element.getTelecom().size(); i++) 9205 composeContactPoint(t, "Person", "telecom", element.getTelecom().get(i), i); 9206 if (element.hasGenderElement()) 9207 composeEnum(t, "Person", "gender", element.getGenderElement(), -1); 9208 if (element.hasBirthDateElement()) 9209 composeDate(t, "Person", "birthDate", element.getBirthDateElement(), -1); 9210 for (int i = 0; i < element.getAddress().size(); i++) 9211 composeAddress(t, "Person", "address", element.getAddress().get(i), i); 9212 if (element.hasPhoto()) 9213 composeAttachment(t, "Person", "photo", element.getPhoto(), -1); 9214 if (element.hasManagingOrganization()) 9215 composeReference(t, "Person", "managingOrganization", element.getManagingOrganization(), -1); 9216 if (element.hasActiveElement()) 9217 composeBoolean(t, "Person", "active", element.getActiveElement(), -1); 9218 for (int i = 0; i < element.getLink().size(); i++) 9219 composePersonPersonLinkComponent(t, "Person", "link", element.getLink().get(i), i); 9220 } 9221 9222 protected void composePersonPersonLinkComponent(Complex parent, String parentType, String name, Person.PersonLinkComponent element, int index) { 9223 if (element == null) 9224 return; 9225 Complex t; 9226 if (Utilities.noString(parentType)) 9227 t = parent; 9228 else { 9229 t = parent.predicate("fhir:"+parentType+'.'+name); 9230 } 9231 composeBackboneElement(t, "link", name, element, index); 9232 if (element.hasTarget()) 9233 composeReference(t, "Person", "target", element.getTarget(), -1); 9234 if (element.hasAssuranceElement()) 9235 composeEnum(t, "Person", "assurance", element.getAssuranceElement(), -1); 9236 } 9237 9238 protected void composePractitioner(Complex parent, String parentType, String name, Practitioner element, int index) { 9239 if (element == null) 9240 return; 9241 Complex t; 9242 if (Utilities.noString(parentType)) 9243 t = parent; 9244 else { 9245 t = parent.predicate("fhir:"+parentType+'.'+name); 9246 } 9247 composeDomainResource(t, "Practitioner", name, element, index); 9248 for (int i = 0; i < element.getIdentifier().size(); i++) 9249 composeIdentifier(t, "Practitioner", "identifier", element.getIdentifier().get(i), i); 9250 if (element.hasActiveElement()) 9251 composeBoolean(t, "Practitioner", "active", element.getActiveElement(), -1); 9252 for (int i = 0; i < element.getName().size(); i++) 9253 composeHumanName(t, "Practitioner", "name", element.getName().get(i), i); 9254 for (int i = 0; i < element.getTelecom().size(); i++) 9255 composeContactPoint(t, "Practitioner", "telecom", element.getTelecom().get(i), i); 9256 for (int i = 0; i < element.getAddress().size(); i++) 9257 composeAddress(t, "Practitioner", "address", element.getAddress().get(i), i); 9258 if (element.hasGenderElement()) 9259 composeEnum(t, "Practitioner", "gender", element.getGenderElement(), -1); 9260 if (element.hasBirthDateElement()) 9261 composeDate(t, "Practitioner", "birthDate", element.getBirthDateElement(), -1); 9262 for (int i = 0; i < element.getPhoto().size(); i++) 9263 composeAttachment(t, "Practitioner", "photo", element.getPhoto().get(i), i); 9264 for (int i = 0; i < element.getPractitionerRole().size(); i++) 9265 composePractitionerPractitionerPractitionerRoleComponent(t, "Practitioner", "practitionerRole", element.getPractitionerRole().get(i), i); 9266 for (int i = 0; i < element.getQualification().size(); i++) 9267 composePractitionerPractitionerQualificationComponent(t, "Practitioner", "qualification", element.getQualification().get(i), i); 9268 for (int i = 0; i < element.getCommunication().size(); i++) 9269 composeCodeableConcept(t, "Practitioner", "communication", element.getCommunication().get(i), i); 9270 } 9271 9272 protected void composePractitionerPractitionerPractitionerRoleComponent(Complex parent, String parentType, String name, Practitioner.PractitionerPractitionerRoleComponent element, int index) { 9273 if (element == null) 9274 return; 9275 Complex t; 9276 if (Utilities.noString(parentType)) 9277 t = parent; 9278 else { 9279 t = parent.predicate("fhir:"+parentType+'.'+name); 9280 } 9281 composeBackboneElement(t, "practitionerRole", name, element, index); 9282 if (element.hasOrganization()) 9283 composeReference(t, "Practitioner", "organization", element.getOrganization(), -1); 9284 if (element.hasRole()) 9285 composeCodeableConcept(t, "Practitioner", "role", element.getRole(), -1); 9286 for (int i = 0; i < element.getSpecialty().size(); i++) 9287 composeCodeableConcept(t, "Practitioner", "specialty", element.getSpecialty().get(i), i); 9288 for (int i = 0; i < element.getIdentifier().size(); i++) 9289 composeIdentifier(t, "Practitioner", "identifier", element.getIdentifier().get(i), i); 9290 for (int i = 0; i < element.getTelecom().size(); i++) 9291 composeContactPoint(t, "Practitioner", "telecom", element.getTelecom().get(i), i); 9292 if (element.hasPeriod()) 9293 composePeriod(t, "Practitioner", "period", element.getPeriod(), -1); 9294 for (int i = 0; i < element.getLocation().size(); i++) 9295 composeReference(t, "Practitioner", "location", element.getLocation().get(i), i); 9296 for (int i = 0; i < element.getHealthcareService().size(); i++) 9297 composeReference(t, "Practitioner", "healthcareService", element.getHealthcareService().get(i), i); 9298 } 9299 9300 protected void composePractitionerPractitionerQualificationComponent(Complex parent, String parentType, String name, Practitioner.PractitionerQualificationComponent element, int index) { 9301 if (element == null) 9302 return; 9303 Complex t; 9304 if (Utilities.noString(parentType)) 9305 t = parent; 9306 else { 9307 t = parent.predicate("fhir:"+parentType+'.'+name); 9308 } 9309 composeBackboneElement(t, "qualification", name, element, index); 9310 for (int i = 0; i < element.getIdentifier().size(); i++) 9311 composeIdentifier(t, "Practitioner", "identifier", element.getIdentifier().get(i), i); 9312 if (element.hasCode()) 9313 composeCodeableConcept(t, "Practitioner", "code", element.getCode(), -1); 9314 if (element.hasPeriod()) 9315 composePeriod(t, "Practitioner", "period", element.getPeriod(), -1); 9316 if (element.hasIssuer()) 9317 composeReference(t, "Practitioner", "issuer", element.getIssuer(), -1); 9318 } 9319 9320 protected void composePractitionerRole(Complex parent, String parentType, String name, PractitionerRole element, int index) { 9321 if (element == null) 9322 return; 9323 Complex t; 9324 if (Utilities.noString(parentType)) 9325 t = parent; 9326 else { 9327 t = parent.predicate("fhir:"+parentType+'.'+name); 9328 } 9329 composeDomainResource(t, "PractitionerRole", name, element, index); 9330 for (int i = 0; i < element.getIdentifier().size(); i++) 9331 composeIdentifier(t, "PractitionerRole", "identifier", element.getIdentifier().get(i), i); 9332 if (element.hasActiveElement()) 9333 composeBoolean(t, "PractitionerRole", "active", element.getActiveElement(), -1); 9334 if (element.hasPractitioner()) 9335 composeReference(t, "PractitionerRole", "practitioner", element.getPractitioner(), -1); 9336 if (element.hasOrganization()) 9337 composeReference(t, "PractitionerRole", "organization", element.getOrganization(), -1); 9338 for (int i = 0; i < element.getRole().size(); i++) 9339 composeCodeableConcept(t, "PractitionerRole", "role", element.getRole().get(i), i); 9340 for (int i = 0; i < element.getSpecialty().size(); i++) 9341 composeCodeableConcept(t, "PractitionerRole", "specialty", element.getSpecialty().get(i), i); 9342 for (int i = 0; i < element.getLocation().size(); i++) 9343 composeReference(t, "PractitionerRole", "location", element.getLocation().get(i), i); 9344 for (int i = 0; i < element.getHealthcareService().size(); i++) 9345 composeReference(t, "PractitionerRole", "healthcareService", element.getHealthcareService().get(i), i); 9346 for (int i = 0; i < element.getTelecom().size(); i++) 9347 composeContactPoint(t, "PractitionerRole", "telecom", element.getTelecom().get(i), i); 9348 if (element.hasPeriod()) 9349 composePeriod(t, "PractitionerRole", "period", element.getPeriod(), -1); 9350 for (int i = 0; i < element.getAvailableTime().size(); i++) 9351 composePractitionerRolePractitionerRoleAvailableTimeComponent(t, "PractitionerRole", "availableTime", element.getAvailableTime().get(i), i); 9352 for (int i = 0; i < element.getNotAvailable().size(); i++) 9353 composePractitionerRolePractitionerRoleNotAvailableComponent(t, "PractitionerRole", "notAvailable", element.getNotAvailable().get(i), i); 9354 if (element.hasAvailabilityExceptionsElement()) 9355 composeString(t, "PractitionerRole", "availabilityExceptions", element.getAvailabilityExceptionsElement(), -1); 9356 } 9357 9358 protected void composePractitionerRolePractitionerRoleAvailableTimeComponent(Complex parent, String parentType, String name, PractitionerRole.PractitionerRoleAvailableTimeComponent element, int index) { 9359 if (element == null) 9360 return; 9361 Complex t; 9362 if (Utilities.noString(parentType)) 9363 t = parent; 9364 else { 9365 t = parent.predicate("fhir:"+parentType+'.'+name); 9366 } 9367 composeBackboneElement(t, "availableTime", name, element, index); 9368 for (int i = 0; i < element.getDaysOfWeek().size(); i++) 9369 composeCode(t, "PractitionerRole", "daysOfWeek", element.getDaysOfWeek().get(i), i); 9370 if (element.hasAllDayElement()) 9371 composeBoolean(t, "PractitionerRole", "allDay", element.getAllDayElement(), -1); 9372 if (element.hasAvailableStartTimeElement()) 9373 composeTime(t, "PractitionerRole", "availableStartTime", element.getAvailableStartTimeElement(), -1); 9374 if (element.hasAvailableEndTimeElement()) 9375 composeTime(t, "PractitionerRole", "availableEndTime", element.getAvailableEndTimeElement(), -1); 9376 } 9377 9378 protected void composePractitionerRolePractitionerRoleNotAvailableComponent(Complex parent, String parentType, String name, PractitionerRole.PractitionerRoleNotAvailableComponent element, int index) { 9379 if (element == null) 9380 return; 9381 Complex t; 9382 if (Utilities.noString(parentType)) 9383 t = parent; 9384 else { 9385 t = parent.predicate("fhir:"+parentType+'.'+name); 9386 } 9387 composeBackboneElement(t, "notAvailable", name, element, index); 9388 if (element.hasDescriptionElement()) 9389 composeString(t, "PractitionerRole", "description", element.getDescriptionElement(), -1); 9390 if (element.hasDuring()) 9391 composePeriod(t, "PractitionerRole", "during", element.getDuring(), -1); 9392 } 9393 9394 protected void composeProcedure(Complex parent, String parentType, String name, Procedure element, int index) { 9395 if (element == null) 9396 return; 9397 Complex t; 9398 if (Utilities.noString(parentType)) 9399 t = parent; 9400 else { 9401 t = parent.predicate("fhir:"+parentType+'.'+name); 9402 } 9403 composeDomainResource(t, "Procedure", name, element, index); 9404 for (int i = 0; i < element.getIdentifier().size(); i++) 9405 composeIdentifier(t, "Procedure", "identifier", element.getIdentifier().get(i), i); 9406 if (element.hasSubject()) 9407 composeReference(t, "Procedure", "subject", element.getSubject(), -1); 9408 if (element.hasStatusElement()) 9409 composeEnum(t, "Procedure", "status", element.getStatusElement(), -1); 9410 if (element.hasCategory()) 9411 composeCodeableConcept(t, "Procedure", "category", element.getCategory(), -1); 9412 if (element.hasCode()) 9413 composeCodeableConcept(t, "Procedure", "code", element.getCode(), -1); 9414 if (element.hasNotPerformedElement()) 9415 composeBoolean(t, "Procedure", "notPerformed", element.getNotPerformedElement(), -1); 9416 for (int i = 0; i < element.getReasonNotPerformed().size(); i++) 9417 composeCodeableConcept(t, "Procedure", "reasonNotPerformed", element.getReasonNotPerformed().get(i), i); 9418 for (int i = 0; i < element.getBodySite().size(); i++) 9419 composeCodeableConcept(t, "Procedure", "bodySite", element.getBodySite().get(i), i); 9420 if (element.hasReason()) 9421 composeType(t, "Procedure", "reason", element.getReason(), -1); 9422 for (int i = 0; i < element.getPerformer().size(); i++) 9423 composeProcedureProcedurePerformerComponent(t, "Procedure", "performer", element.getPerformer().get(i), i); 9424 if (element.hasPerformed()) 9425 composeType(t, "Procedure", "performed", element.getPerformed(), -1); 9426 if (element.hasEncounter()) 9427 composeReference(t, "Procedure", "encounter", element.getEncounter(), -1); 9428 if (element.hasLocation()) 9429 composeReference(t, "Procedure", "location", element.getLocation(), -1); 9430 if (element.hasOutcome()) 9431 composeCodeableConcept(t, "Procedure", "outcome", element.getOutcome(), -1); 9432 for (int i = 0; i < element.getReport().size(); i++) 9433 composeReference(t, "Procedure", "report", element.getReport().get(i), i); 9434 for (int i = 0; i < element.getComplication().size(); i++) 9435 composeCodeableConcept(t, "Procedure", "complication", element.getComplication().get(i), i); 9436 for (int i = 0; i < element.getFollowUp().size(); i++) 9437 composeCodeableConcept(t, "Procedure", "followUp", element.getFollowUp().get(i), i); 9438 if (element.hasRequest()) 9439 composeReference(t, "Procedure", "request", element.getRequest(), -1); 9440 for (int i = 0; i < element.getNotes().size(); i++) 9441 composeAnnotation(t, "Procedure", "notes", element.getNotes().get(i), i); 9442 for (int i = 0; i < element.getFocalDevice().size(); i++) 9443 composeProcedureProcedureFocalDeviceComponent(t, "Procedure", "focalDevice", element.getFocalDevice().get(i), i); 9444 for (int i = 0; i < element.getUsed().size(); i++) 9445 composeReference(t, "Procedure", "used", element.getUsed().get(i), i); 9446 } 9447 9448 protected void composeProcedureProcedurePerformerComponent(Complex parent, String parentType, String name, Procedure.ProcedurePerformerComponent element, int index) { 9449 if (element == null) 9450 return; 9451 Complex t; 9452 if (Utilities.noString(parentType)) 9453 t = parent; 9454 else { 9455 t = parent.predicate("fhir:"+parentType+'.'+name); 9456 } 9457 composeBackboneElement(t, "performer", name, element, index); 9458 if (element.hasActor()) 9459 composeReference(t, "Procedure", "actor", element.getActor(), -1); 9460 if (element.hasRole()) 9461 composeCodeableConcept(t, "Procedure", "role", element.getRole(), -1); 9462 } 9463 9464 protected void composeProcedureProcedureFocalDeviceComponent(Complex parent, String parentType, String name, Procedure.ProcedureFocalDeviceComponent element, int index) { 9465 if (element == null) 9466 return; 9467 Complex t; 9468 if (Utilities.noString(parentType)) 9469 t = parent; 9470 else { 9471 t = parent.predicate("fhir:"+parentType+'.'+name); 9472 } 9473 composeBackboneElement(t, "focalDevice", name, element, index); 9474 if (element.hasAction()) 9475 composeCodeableConcept(t, "Procedure", "action", element.getAction(), -1); 9476 if (element.hasManipulated()) 9477 composeReference(t, "Procedure", "manipulated", element.getManipulated(), -1); 9478 } 9479 9480 protected void composeProcedureRequest(Complex parent, String parentType, String name, ProcedureRequest element, int index) { 9481 if (element == null) 9482 return; 9483 Complex t; 9484 if (Utilities.noString(parentType)) 9485 t = parent; 9486 else { 9487 t = parent.predicate("fhir:"+parentType+'.'+name); 9488 } 9489 composeDomainResource(t, "ProcedureRequest", name, element, index); 9490 for (int i = 0; i < element.getIdentifier().size(); i++) 9491 composeIdentifier(t, "ProcedureRequest", "identifier", element.getIdentifier().get(i), i); 9492 if (element.hasSubject()) 9493 composeReference(t, "ProcedureRequest", "subject", element.getSubject(), -1); 9494 if (element.hasCode()) 9495 composeCodeableConcept(t, "ProcedureRequest", "code", element.getCode(), -1); 9496 for (int i = 0; i < element.getBodySite().size(); i++) 9497 composeCodeableConcept(t, "ProcedureRequest", "bodySite", element.getBodySite().get(i), i); 9498 if (element.hasReason()) 9499 composeType(t, "ProcedureRequest", "reason", element.getReason(), -1); 9500 if (element.hasScheduled()) 9501 composeType(t, "ProcedureRequest", "scheduled", element.getScheduled(), -1); 9502 if (element.hasEncounter()) 9503 composeReference(t, "ProcedureRequest", "encounter", element.getEncounter(), -1); 9504 if (element.hasPerformer()) 9505 composeReference(t, "ProcedureRequest", "performer", element.getPerformer(), -1); 9506 if (element.hasStatusElement()) 9507 composeEnum(t, "ProcedureRequest", "status", element.getStatusElement(), -1); 9508 for (int i = 0; i < element.getNotes().size(); i++) 9509 composeAnnotation(t, "ProcedureRequest", "notes", element.getNotes().get(i), i); 9510 if (element.hasAsNeeded()) 9511 composeType(t, "ProcedureRequest", "asNeeded", element.getAsNeeded(), -1); 9512 if (element.hasOrderedOnElement()) 9513 composeDateTime(t, "ProcedureRequest", "orderedOn", element.getOrderedOnElement(), -1); 9514 if (element.hasOrderer()) 9515 composeReference(t, "ProcedureRequest", "orderer", element.getOrderer(), -1); 9516 if (element.hasPriorityElement()) 9517 composeEnum(t, "ProcedureRequest", "priority", element.getPriorityElement(), -1); 9518 } 9519 9520 protected void composeProcessRequest(Complex parent, String parentType, String name, ProcessRequest element, int index) { 9521 if (element == null) 9522 return; 9523 Complex t; 9524 if (Utilities.noString(parentType)) 9525 t = parent; 9526 else { 9527 t = parent.predicate("fhir:"+parentType+'.'+name); 9528 } 9529 composeDomainResource(t, "ProcessRequest", name, element, index); 9530 if (element.hasActionElement()) 9531 composeEnum(t, "ProcessRequest", "action", element.getActionElement(), -1); 9532 for (int i = 0; i < element.getIdentifier().size(); i++) 9533 composeIdentifier(t, "ProcessRequest", "identifier", element.getIdentifier().get(i), i); 9534 if (element.hasRuleset()) 9535 composeCoding(t, "ProcessRequest", "ruleset", element.getRuleset(), -1); 9536 if (element.hasOriginalRuleset()) 9537 composeCoding(t, "ProcessRequest", "originalRuleset", element.getOriginalRuleset(), -1); 9538 if (element.hasCreatedElement()) 9539 composeDateTime(t, "ProcessRequest", "created", element.getCreatedElement(), -1); 9540 if (element.hasTarget()) 9541 composeType(t, "ProcessRequest", "target", element.getTarget(), -1); 9542 if (element.hasProvider()) 9543 composeType(t, "ProcessRequest", "provider", element.getProvider(), -1); 9544 if (element.hasOrganization()) 9545 composeType(t, "ProcessRequest", "organization", element.getOrganization(), -1); 9546 if (element.hasRequest()) 9547 composeType(t, "ProcessRequest", "request", element.getRequest(), -1); 9548 if (element.hasResponse()) 9549 composeType(t, "ProcessRequest", "response", element.getResponse(), -1); 9550 if (element.hasNullifyElement()) 9551 composeBoolean(t, "ProcessRequest", "nullify", element.getNullifyElement(), -1); 9552 if (element.hasReferenceElement()) 9553 composeString(t, "ProcessRequest", "reference", element.getReferenceElement(), -1); 9554 for (int i = 0; i < element.getItem().size(); i++) 9555 composeProcessRequestItemsComponent(t, "ProcessRequest", "item", element.getItem().get(i), i); 9556 for (int i = 0; i < element.getInclude().size(); i++) 9557 composeString(t, "ProcessRequest", "include", element.getInclude().get(i), i); 9558 for (int i = 0; i < element.getExclude().size(); i++) 9559 composeString(t, "ProcessRequest", "exclude", element.getExclude().get(i), i); 9560 if (element.hasPeriod()) 9561 composePeriod(t, "ProcessRequest", "period", element.getPeriod(), -1); 9562 } 9563 9564 protected void composeProcessRequestItemsComponent(Complex parent, String parentType, String name, ProcessRequest.ItemsComponent element, int index) { 9565 if (element == null) 9566 return; 9567 Complex t; 9568 if (Utilities.noString(parentType)) 9569 t = parent; 9570 else { 9571 t = parent.predicate("fhir:"+parentType+'.'+name); 9572 } 9573 composeBackboneElement(t, "item", name, element, index); 9574 if (element.hasSequenceLinkIdElement()) 9575 composeInteger(t, "ProcessRequest", "sequenceLinkId", element.getSequenceLinkIdElement(), -1); 9576 } 9577 9578 protected void composeProcessResponse(Complex parent, String parentType, String name, ProcessResponse element, int index) { 9579 if (element == null) 9580 return; 9581 Complex t; 9582 if (Utilities.noString(parentType)) 9583 t = parent; 9584 else { 9585 t = parent.predicate("fhir:"+parentType+'.'+name); 9586 } 9587 composeDomainResource(t, "ProcessResponse", name, element, index); 9588 for (int i = 0; i < element.getIdentifier().size(); i++) 9589 composeIdentifier(t, "ProcessResponse", "identifier", element.getIdentifier().get(i), i); 9590 if (element.hasRequest()) 9591 composeType(t, "ProcessResponse", "request", element.getRequest(), -1); 9592 if (element.hasOutcome()) 9593 composeCoding(t, "ProcessResponse", "outcome", element.getOutcome(), -1); 9594 if (element.hasDispositionElement()) 9595 composeString(t, "ProcessResponse", "disposition", element.getDispositionElement(), -1); 9596 if (element.hasRuleset()) 9597 composeCoding(t, "ProcessResponse", "ruleset", element.getRuleset(), -1); 9598 if (element.hasOriginalRuleset()) 9599 composeCoding(t, "ProcessResponse", "originalRuleset", element.getOriginalRuleset(), -1); 9600 if (element.hasCreatedElement()) 9601 composeDateTime(t, "ProcessResponse", "created", element.getCreatedElement(), -1); 9602 if (element.hasOrganization()) 9603 composeType(t, "ProcessResponse", "organization", element.getOrganization(), -1); 9604 if (element.hasRequestProvider()) 9605 composeType(t, "ProcessResponse", "requestProvider", element.getRequestProvider(), -1); 9606 if (element.hasRequestOrganization()) 9607 composeType(t, "ProcessResponse", "requestOrganization", element.getRequestOrganization(), -1); 9608 if (element.hasForm()) 9609 composeCoding(t, "ProcessResponse", "form", element.getForm(), -1); 9610 for (int i = 0; i < element.getNotes().size(); i++) 9611 composeProcessResponseProcessResponseNotesComponent(t, "ProcessResponse", "notes", element.getNotes().get(i), i); 9612 for (int i = 0; i < element.getError().size(); i++) 9613 composeCoding(t, "ProcessResponse", "error", element.getError().get(i), i); 9614 } 9615 9616 protected void composeProcessResponseProcessResponseNotesComponent(Complex parent, String parentType, String name, ProcessResponse.ProcessResponseNotesComponent element, int index) { 9617 if (element == null) 9618 return; 9619 Complex t; 9620 if (Utilities.noString(parentType)) 9621 t = parent; 9622 else { 9623 t = parent.predicate("fhir:"+parentType+'.'+name); 9624 } 9625 composeBackboneElement(t, "notes", name, element, index); 9626 if (element.hasType()) 9627 composeCoding(t, "ProcessResponse", "type", element.getType(), -1); 9628 if (element.hasTextElement()) 9629 composeString(t, "ProcessResponse", "text", element.getTextElement(), -1); 9630 } 9631 9632 protected void composeProtocol(Complex parent, String parentType, String name, Protocol element, int index) { 9633 if (element == null) 9634 return; 9635 Complex t; 9636 if (Utilities.noString(parentType)) 9637 t = parent; 9638 else { 9639 t = parent.predicate("fhir:"+parentType+'.'+name); 9640 } 9641 composeDomainResource(t, "Protocol", name, element, index); 9642 for (int i = 0; i < element.getIdentifier().size(); i++) 9643 composeIdentifier(t, "Protocol", "identifier", element.getIdentifier().get(i), i); 9644 if (element.hasTitleElement()) 9645 composeString(t, "Protocol", "title", element.getTitleElement(), -1); 9646 if (element.hasStatusElement()) 9647 composeEnum(t, "Protocol", "status", element.getStatusElement(), -1); 9648 if (element.hasTypeElement()) 9649 composeEnum(t, "Protocol", "type", element.getTypeElement(), -1); 9650 if (element.hasSubject()) 9651 composeReference(t, "Protocol", "subject", element.getSubject(), -1); 9652 if (element.hasGroup()) 9653 composeReference(t, "Protocol", "group", element.getGroup(), -1); 9654 if (element.hasPurposeElement()) 9655 composeString(t, "Protocol", "purpose", element.getPurposeElement(), -1); 9656 if (element.hasAuthor()) 9657 composeReference(t, "Protocol", "author", element.getAuthor(), -1); 9658 for (int i = 0; i < element.getStep().size(); i++) 9659 composeProtocolProtocolStepComponent(t, "Protocol", "step", element.getStep().get(i), i); 9660 } 9661 9662 protected void composeProtocolProtocolStepComponent(Complex parent, String parentType, String name, Protocol.ProtocolStepComponent element, int index) { 9663 if (element == null) 9664 return; 9665 Complex t; 9666 if (Utilities.noString(parentType)) 9667 t = parent; 9668 else { 9669 t = parent.predicate("fhir:"+parentType+'.'+name); 9670 } 9671 composeBackboneElement(t, "step", name, element, index); 9672 if (element.hasNameElement()) 9673 composeString(t, "Protocol", "name", element.getNameElement(), -1); 9674 if (element.hasDescriptionElement()) 9675 composeString(t, "Protocol", "description", element.getDescriptionElement(), -1); 9676 if (element.hasDuration()) 9677 composeQuantity(t, "Protocol", "duration", element.getDuration(), -1); 9678 if (element.hasPrecondition()) 9679 composeProtocolProtocolStepPreconditionComponent(t, "Protocol", "precondition", element.getPrecondition(), -1); 9680 if (element.hasExit()) 9681 composeProtocolProtocolStepPreconditionComponent(t, "Protocol", "exit", element.getExit(), -1); 9682 if (element.hasFirstActivityElement()) 9683 composeUri(t, "Protocol", "firstActivity", element.getFirstActivityElement(), -1); 9684 for (int i = 0; i < element.getActivity().size(); i++) 9685 composeProtocolProtocolStepActivityComponent(t, "Protocol", "activity", element.getActivity().get(i), i); 9686 for (int i = 0; i < element.getNext().size(); i++) 9687 composeProtocolProtocolStepNextComponent(t, "Protocol", "next", element.getNext().get(i), i); 9688 } 9689 9690 protected void composeProtocolProtocolStepPreconditionComponent(Complex parent, String parentType, String name, Protocol.ProtocolStepPreconditionComponent element, int index) { 9691 if (element == null) 9692 return; 9693 Complex t; 9694 if (Utilities.noString(parentType)) 9695 t = parent; 9696 else { 9697 t = parent.predicate("fhir:"+parentType+'.'+name); 9698 } 9699 composeBackboneElement(t, "precondition", name, element, index); 9700 if (element.hasDescriptionElement()) 9701 composeString(t, "Protocol", "description", element.getDescriptionElement(), -1); 9702 if (element.hasCondition()) 9703 composeProtocolProtocolStepPreconditionConditionComponent(t, "Protocol", "condition", element.getCondition(), -1); 9704 for (int i = 0; i < element.getIntersection().size(); i++) 9705 composeProtocolProtocolStepPreconditionComponent(t, "Protocol", "intersection", element.getIntersection().get(i), i); 9706 for (int i = 0; i < element.getUnion().size(); i++) 9707 composeProtocolProtocolStepPreconditionComponent(t, "Protocol", "union", element.getUnion().get(i), i); 9708 for (int i = 0; i < element.getExclude().size(); i++) 9709 composeProtocolProtocolStepPreconditionComponent(t, "Protocol", "exclude", element.getExclude().get(i), i); 9710 } 9711 9712 protected void composeProtocolProtocolStepPreconditionConditionComponent(Complex parent, String parentType, String name, Protocol.ProtocolStepPreconditionConditionComponent element, int index) { 9713 if (element == null) 9714 return; 9715 Complex t; 9716 if (Utilities.noString(parentType)) 9717 t = parent; 9718 else { 9719 t = parent.predicate("fhir:"+parentType+'.'+name); 9720 } 9721 composeBackboneElement(t, "condition", name, element, index); 9722 if (element.hasType()) 9723 composeCodeableConcept(t, "Protocol", "type", element.getType(), -1); 9724 if (element.hasValue()) 9725 composeType(t, "Protocol", "value", element.getValue(), -1); 9726 } 9727 9728 protected void composeProtocolProtocolStepActivityComponent(Complex parent, String parentType, String name, Protocol.ProtocolStepActivityComponent element, int index) { 9729 if (element == null) 9730 return; 9731 Complex t; 9732 if (Utilities.noString(parentType)) 9733 t = parent; 9734 else { 9735 t = parent.predicate("fhir:"+parentType+'.'+name); 9736 } 9737 composeBackboneElement(t, "activity", name, element, index); 9738 for (int i = 0; i < element.getAlternative().size(); i++) 9739 composeUri(t, "Protocol", "alternative", element.getAlternative().get(i), i); 9740 for (int i = 0; i < element.getComponent().size(); i++) 9741 composeProtocolProtocolStepActivityComponentComponent(t, "Protocol", "component", element.getComponent().get(i), i); 9742 for (int i = 0; i < element.getFollowing().size(); i++) 9743 composeUri(t, "Protocol", "following", element.getFollowing().get(i), i); 9744 if (element.hasWait()) 9745 composeQuantity(t, "Protocol", "wait", element.getWait(), -1); 9746 if (element.hasDetail()) 9747 composeProtocolProtocolStepActivityDetailComponent(t, "Protocol", "detail", element.getDetail(), -1); 9748 } 9749 9750 protected void composeProtocolProtocolStepActivityComponentComponent(Complex parent, String parentType, String name, Protocol.ProtocolStepActivityComponentComponent element, int index) { 9751 if (element == null) 9752 return; 9753 Complex t; 9754 if (Utilities.noString(parentType)) 9755 t = parent; 9756 else { 9757 t = parent.predicate("fhir:"+parentType+'.'+name); 9758 } 9759 composeBackboneElement(t, "component", name, element, index); 9760 if (element.hasSequenceElement()) 9761 composeInteger(t, "Protocol", "sequence", element.getSequenceElement(), -1); 9762 if (element.hasActivityElement()) 9763 composeUri(t, "Protocol", "activity", element.getActivityElement(), -1); 9764 } 9765 9766 protected void composeProtocolProtocolStepActivityDetailComponent(Complex parent, String parentType, String name, Protocol.ProtocolStepActivityDetailComponent element, int index) { 9767 if (element == null) 9768 return; 9769 Complex t; 9770 if (Utilities.noString(parentType)) 9771 t = parent; 9772 else { 9773 t = parent.predicate("fhir:"+parentType+'.'+name); 9774 } 9775 composeBackboneElement(t, "detail", name, element, index); 9776 if (element.hasCategoryElement()) 9777 composeEnum(t, "Protocol", "category", element.getCategoryElement(), -1); 9778 if (element.hasCode()) 9779 composeCodeableConcept(t, "Protocol", "code", element.getCode(), -1); 9780 if (element.hasTiming()) 9781 composeType(t, "Protocol", "timing", element.getTiming(), -1); 9782 if (element.hasLocation()) 9783 composeReference(t, "Protocol", "location", element.getLocation(), -1); 9784 for (int i = 0; i < element.getPerformer().size(); i++) 9785 composeReference(t, "Protocol", "performer", element.getPerformer().get(i), i); 9786 if (element.hasProduct()) 9787 composeReference(t, "Protocol", "product", element.getProduct(), -1); 9788 if (element.hasQuantity()) 9789 composeQuantity(t, "Protocol", "quantity", element.getQuantity(), -1); 9790 if (element.hasDescriptionElement()) 9791 composeString(t, "Protocol", "description", element.getDescriptionElement(), -1); 9792 } 9793 9794 protected void composeProtocolProtocolStepNextComponent(Complex parent, String parentType, String name, Protocol.ProtocolStepNextComponent element, int index) { 9795 if (element == null) 9796 return; 9797 Complex t; 9798 if (Utilities.noString(parentType)) 9799 t = parent; 9800 else { 9801 t = parent.predicate("fhir:"+parentType+'.'+name); 9802 } 9803 composeBackboneElement(t, "next", name, element, index); 9804 if (element.hasDescriptionElement()) 9805 composeString(t, "Protocol", "description", element.getDescriptionElement(), -1); 9806 if (element.hasReferenceElement()) 9807 composeUri(t, "Protocol", "reference", element.getReferenceElement(), -1); 9808 if (element.hasCondition()) 9809 composeProtocolProtocolStepPreconditionComponent(t, "Protocol", "condition", element.getCondition(), -1); 9810 } 9811 9812 protected void composeProvenance(Complex parent, String parentType, String name, Provenance element, int index) { 9813 if (element == null) 9814 return; 9815 Complex t; 9816 if (Utilities.noString(parentType)) 9817 t = parent; 9818 else { 9819 t = parent.predicate("fhir:"+parentType+'.'+name); 9820 } 9821 composeDomainResource(t, "Provenance", name, element, index); 9822 for (int i = 0; i < element.getTarget().size(); i++) 9823 composeReference(t, "Provenance", "target", element.getTarget().get(i), i); 9824 if (element.hasPeriod()) 9825 composePeriod(t, "Provenance", "period", element.getPeriod(), -1); 9826 if (element.hasRecordedElement()) 9827 composeInstant(t, "Provenance", "recorded", element.getRecordedElement(), -1); 9828 for (int i = 0; i < element.getReason().size(); i++) 9829 composeCoding(t, "Provenance", "reason", element.getReason().get(i), i); 9830 if (element.hasActivity()) 9831 composeCoding(t, "Provenance", "activity", element.getActivity(), -1); 9832 if (element.hasLocation()) 9833 composeReference(t, "Provenance", "location", element.getLocation(), -1); 9834 for (int i = 0; i < element.getPolicy().size(); i++) 9835 composeUri(t, "Provenance", "policy", element.getPolicy().get(i), i); 9836 for (int i = 0; i < element.getAgent().size(); i++) 9837 composeProvenanceProvenanceAgentComponent(t, "Provenance", "agent", element.getAgent().get(i), i); 9838 for (int i = 0; i < element.getEntity().size(); i++) 9839 composeProvenanceProvenanceEntityComponent(t, "Provenance", "entity", element.getEntity().get(i), i); 9840 for (int i = 0; i < element.getSignature().size(); i++) 9841 composeSignature(t, "Provenance", "signature", element.getSignature().get(i), i); 9842 } 9843 9844 protected void composeProvenanceProvenanceAgentComponent(Complex parent, String parentType, String name, Provenance.ProvenanceAgentComponent element, int index) { 9845 if (element == null) 9846 return; 9847 Complex t; 9848 if (Utilities.noString(parentType)) 9849 t = parent; 9850 else { 9851 t = parent.predicate("fhir:"+parentType+'.'+name); 9852 } 9853 composeBackboneElement(t, "agent", name, element, index); 9854 if (element.hasRole()) 9855 composeCoding(t, "Provenance", "role", element.getRole(), -1); 9856 if (element.hasActor()) 9857 composeReference(t, "Provenance", "actor", element.getActor(), -1); 9858 if (element.hasUserId()) 9859 composeIdentifier(t, "Provenance", "userId", element.getUserId(), -1); 9860 for (int i = 0; i < element.getRelatedAgent().size(); i++) 9861 composeProvenanceProvenanceAgentRelatedAgentComponent(t, "Provenance", "relatedAgent", element.getRelatedAgent().get(i), i); 9862 } 9863 9864 protected void composeProvenanceProvenanceAgentRelatedAgentComponent(Complex parent, String parentType, String name, Provenance.ProvenanceAgentRelatedAgentComponent element, int index) { 9865 if (element == null) 9866 return; 9867 Complex t; 9868 if (Utilities.noString(parentType)) 9869 t = parent; 9870 else { 9871 t = parent.predicate("fhir:"+parentType+'.'+name); 9872 } 9873 composeBackboneElement(t, "relatedAgent", name, element, index); 9874 if (element.hasType()) 9875 composeCodeableConcept(t, "Provenance", "type", element.getType(), -1); 9876 if (element.hasTargetElement()) 9877 composeUri(t, "Provenance", "target", element.getTargetElement(), -1); 9878 } 9879 9880 protected void composeProvenanceProvenanceEntityComponent(Complex parent, String parentType, String name, Provenance.ProvenanceEntityComponent element, int index) { 9881 if (element == null) 9882 return; 9883 Complex t; 9884 if (Utilities.noString(parentType)) 9885 t = parent; 9886 else { 9887 t = parent.predicate("fhir:"+parentType+'.'+name); 9888 } 9889 composeBackboneElement(t, "entity", name, element, index); 9890 if (element.hasRoleElement()) 9891 composeEnum(t, "Provenance", "role", element.getRoleElement(), -1); 9892 if (element.hasType()) 9893 composeCoding(t, "Provenance", "type", element.getType(), -1); 9894 if (element.hasReferenceElement()) 9895 composeUri(t, "Provenance", "reference", element.getReferenceElement(), -1); 9896 if (element.hasDisplayElement()) 9897 composeString(t, "Provenance", "display", element.getDisplayElement(), -1); 9898 if (element.hasAgent()) 9899 composeProvenanceProvenanceAgentComponent(t, "Provenance", "agent", element.getAgent(), -1); 9900 } 9901 9902 protected void composeQuestionnaire(Complex parent, String parentType, String name, Questionnaire element, int index) { 9903 if (element == null) 9904 return; 9905 Complex t; 9906 if (Utilities.noString(parentType)) 9907 t = parent; 9908 else { 9909 t = parent.predicate("fhir:"+parentType+'.'+name); 9910 } 9911 composeDomainResource(t, "Questionnaire", name, element, index); 9912 if (element.hasUrlElement()) 9913 composeUri(t, "Questionnaire", "url", element.getUrlElement(), -1); 9914 for (int i = 0; i < element.getIdentifier().size(); i++) 9915 composeIdentifier(t, "Questionnaire", "identifier", element.getIdentifier().get(i), i); 9916 if (element.hasVersionElement()) 9917 composeString(t, "Questionnaire", "version", element.getVersionElement(), -1); 9918 if (element.hasStatusElement()) 9919 composeEnum(t, "Questionnaire", "status", element.getStatusElement(), -1); 9920 if (element.hasDateElement()) 9921 composeDateTime(t, "Questionnaire", "date", element.getDateElement(), -1); 9922 if (element.hasPublisherElement()) 9923 composeString(t, "Questionnaire", "publisher", element.getPublisherElement(), -1); 9924 for (int i = 0; i < element.getTelecom().size(); i++) 9925 composeContactPoint(t, "Questionnaire", "telecom", element.getTelecom().get(i), i); 9926 for (int i = 0; i < element.getUseContext().size(); i++) 9927 composeCodeableConcept(t, "Questionnaire", "useContext", element.getUseContext().get(i), i); 9928 if (element.hasTitleElement()) 9929 composeString(t, "Questionnaire", "title", element.getTitleElement(), -1); 9930 for (int i = 0; i < element.getConcept().size(); i++) 9931 composeCoding(t, "Questionnaire", "concept", element.getConcept().get(i), i); 9932 for (int i = 0; i < element.getSubjectType().size(); i++) 9933 composeCode(t, "Questionnaire", "subjectType", element.getSubjectType().get(i), i); 9934 for (int i = 0; i < element.getItem().size(); i++) 9935 composeQuestionnaireQuestionnaireItemComponent(t, "Questionnaire", "item", element.getItem().get(i), i); 9936 } 9937 9938 protected void composeQuestionnaireQuestionnaireItemComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemComponent element, int index) { 9939 if (element == null) 9940 return; 9941 Complex t; 9942 if (Utilities.noString(parentType)) 9943 t = parent; 9944 else { 9945 t = parent.predicate("fhir:"+parentType+'.'+name); 9946 } 9947 composeBackboneElement(t, "item", name, element, index); 9948 if (element.hasLinkIdElement()) 9949 composeString(t, "Questionnaire", "linkId", element.getLinkIdElement(), -1); 9950 for (int i = 0; i < element.getConcept().size(); i++) 9951 composeCoding(t, "Questionnaire", "concept", element.getConcept().get(i), i); 9952 if (element.hasPrefixElement()) 9953 composeString(t, "Questionnaire", "prefix", element.getPrefixElement(), -1); 9954 if (element.hasTextElement()) 9955 composeString(t, "Questionnaire", "text", element.getTextElement(), -1); 9956 if (element.hasTypeElement()) 9957 composeEnum(t, "Questionnaire", "type", element.getTypeElement(), -1); 9958 for (int i = 0; i < element.getEnableWhen().size(); i++) 9959 composeQuestionnaireQuestionnaireItemEnableWhenComponent(t, "Questionnaire", "enableWhen", element.getEnableWhen().get(i), i); 9960 if (element.hasRequiredElement()) 9961 composeBoolean(t, "Questionnaire", "required", element.getRequiredElement(), -1); 9962 if (element.hasRepeatsElement()) 9963 composeBoolean(t, "Questionnaire", "repeats", element.getRepeatsElement(), -1); 9964 if (element.hasReadOnlyElement()) 9965 composeBoolean(t, "Questionnaire", "readOnly", element.getReadOnlyElement(), -1); 9966 if (element.hasMaxLengthElement()) 9967 composeInteger(t, "Questionnaire", "maxLength", element.getMaxLengthElement(), -1); 9968 if (element.hasOptions()) 9969 composeReference(t, "Questionnaire", "options", element.getOptions(), -1); 9970 for (int i = 0; i < element.getOption().size(); i++) 9971 composeQuestionnaireQuestionnaireItemOptionComponent(t, "Questionnaire", "option", element.getOption().get(i), i); 9972 if (element.hasInitial()) 9973 composeType(t, "Questionnaire", "initial", element.getInitial(), -1); 9974 for (int i = 0; i < element.getItem().size(); i++) 9975 composeQuestionnaireQuestionnaireItemComponent(t, "Questionnaire", "item", element.getItem().get(i), i); 9976 } 9977 9978 protected void composeQuestionnaireQuestionnaireItemEnableWhenComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemEnableWhenComponent element, int index) { 9979 if (element == null) 9980 return; 9981 Complex t; 9982 if (Utilities.noString(parentType)) 9983 t = parent; 9984 else { 9985 t = parent.predicate("fhir:"+parentType+'.'+name); 9986 } 9987 composeBackboneElement(t, "enableWhen", name, element, index); 9988 if (element.hasQuestionElement()) 9989 composeString(t, "Questionnaire", "question", element.getQuestionElement(), -1); 9990 if (element.hasAnsweredElement()) 9991 composeBoolean(t, "Questionnaire", "answered", element.getAnsweredElement(), -1); 9992 if (element.hasAnswer()) 9993 composeType(t, "Questionnaire", "answer", element.getAnswer(), -1); 9994 } 9995 9996 protected void composeQuestionnaireQuestionnaireItemOptionComponent(Complex parent, String parentType, String name, Questionnaire.QuestionnaireItemOptionComponent element, int index) { 9997 if (element == null) 9998 return; 9999 Complex t; 10000 if (Utilities.noString(parentType)) 10001 t = parent; 10002 else { 10003 t = parent.predicate("fhir:"+parentType+'.'+name); 10004 } 10005 composeBackboneElement(t, "option", name, element, index); 10006 if (element.hasValue()) 10007 composeType(t, "Questionnaire", "value", element.getValue(), -1); 10008 } 10009 10010 protected void composeQuestionnaireResponse(Complex parent, String parentType, String name, QuestionnaireResponse element, int index) { 10011 if (element == null) 10012 return; 10013 Complex t; 10014 if (Utilities.noString(parentType)) 10015 t = parent; 10016 else { 10017 t = parent.predicate("fhir:"+parentType+'.'+name); 10018 } 10019 composeDomainResource(t, "QuestionnaireResponse", name, element, index); 10020 if (element.hasIdentifier()) 10021 composeIdentifier(t, "QuestionnaireResponse", "identifier", element.getIdentifier(), -1); 10022 if (element.hasQuestionnaire()) 10023 composeReference(t, "QuestionnaireResponse", "questionnaire", element.getQuestionnaire(), -1); 10024 if (element.hasStatusElement()) 10025 composeEnum(t, "QuestionnaireResponse", "status", element.getStatusElement(), -1); 10026 if (element.hasSubject()) 10027 composeReference(t, "QuestionnaireResponse", "subject", element.getSubject(), -1); 10028 if (element.hasAuthor()) 10029 composeReference(t, "QuestionnaireResponse", "author", element.getAuthor(), -1); 10030 if (element.hasAuthoredElement()) 10031 composeDateTime(t, "QuestionnaireResponse", "authored", element.getAuthoredElement(), -1); 10032 if (element.hasSource()) 10033 composeReference(t, "QuestionnaireResponse", "source", element.getSource(), -1); 10034 if (element.hasEncounter()) 10035 composeReference(t, "QuestionnaireResponse", "encounter", element.getEncounter(), -1); 10036 for (int i = 0; i < element.getItem().size(); i++) 10037 composeQuestionnaireResponseQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i); 10038 } 10039 10040 protected void composeQuestionnaireResponseQuestionnaireResponseItemComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemComponent element, int index) { 10041 if (element == null) 10042 return; 10043 Complex t; 10044 if (Utilities.noString(parentType)) 10045 t = parent; 10046 else { 10047 t = parent.predicate("fhir:"+parentType+'.'+name); 10048 } 10049 composeBackboneElement(t, "item", name, element, index); 10050 if (element.hasLinkIdElement()) 10051 composeString(t, "QuestionnaireResponse", "linkId", element.getLinkIdElement(), -1); 10052 if (element.hasTextElement()) 10053 composeString(t, "QuestionnaireResponse", "text", element.getTextElement(), -1); 10054 if (element.hasSubject()) 10055 composeReference(t, "QuestionnaireResponse", "subject", element.getSubject(), -1); 10056 for (int i = 0; i < element.getAnswer().size(); i++) 10057 composeQuestionnaireResponseQuestionnaireResponseItemAnswerComponent(t, "QuestionnaireResponse", "answer", element.getAnswer().get(i), i); 10058 for (int i = 0; i < element.getItem().size(); i++) 10059 composeQuestionnaireResponseQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i); 10060 } 10061 10062 protected void composeQuestionnaireResponseQuestionnaireResponseItemAnswerComponent(Complex parent, String parentType, String name, QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent element, int index) { 10063 if (element == null) 10064 return; 10065 Complex t; 10066 if (Utilities.noString(parentType)) 10067 t = parent; 10068 else { 10069 t = parent.predicate("fhir:"+parentType+'.'+name); 10070 } 10071 composeBackboneElement(t, "answer", name, element, index); 10072 if (element.hasValue()) 10073 composeType(t, "QuestionnaireResponse", "value", element.getValue(), -1); 10074 for (int i = 0; i < element.getItem().size(); i++) 10075 composeQuestionnaireResponseQuestionnaireResponseItemComponent(t, "QuestionnaireResponse", "item", element.getItem().get(i), i); 10076 } 10077 10078 protected void composeReferralRequest(Complex parent, String parentType, String name, ReferralRequest element, int index) { 10079 if (element == null) 10080 return; 10081 Complex t; 10082 if (Utilities.noString(parentType)) 10083 t = parent; 10084 else { 10085 t = parent.predicate("fhir:"+parentType+'.'+name); 10086 } 10087 composeDomainResource(t, "ReferralRequest", name, element, index); 10088 for (int i = 0; i < element.getIdentifier().size(); i++) 10089 composeIdentifier(t, "ReferralRequest", "identifier", element.getIdentifier().get(i), i); 10090 for (int i = 0; i < element.getBasedOn().size(); i++) 10091 composeReference(t, "ReferralRequest", "basedOn", element.getBasedOn().get(i), i); 10092 if (element.hasParent()) 10093 composeIdentifier(t, "ReferralRequest", "parent", element.getParent(), -1); 10094 if (element.hasStatusElement()) 10095 composeEnum(t, "ReferralRequest", "status", element.getStatusElement(), -1); 10096 if (element.hasCategoryElement()) 10097 composeEnum(t, "ReferralRequest", "category", element.getCategoryElement(), -1); 10098 if (element.hasType()) 10099 composeCodeableConcept(t, "ReferralRequest", "type", element.getType(), -1); 10100 if (element.hasPriority()) 10101 composeCodeableConcept(t, "ReferralRequest", "priority", element.getPriority(), -1); 10102 if (element.hasPatient()) 10103 composeReference(t, "ReferralRequest", "patient", element.getPatient(), -1); 10104 if (element.hasContext()) 10105 composeReference(t, "ReferralRequest", "context", element.getContext(), -1); 10106 if (element.hasFulfillmentTime()) 10107 composePeriod(t, "ReferralRequest", "fulfillmentTime", element.getFulfillmentTime(), -1); 10108 if (element.hasAuthoredElement()) 10109 composeDateTime(t, "ReferralRequest", "authored", element.getAuthoredElement(), -1); 10110 if (element.hasRequester()) 10111 composeReference(t, "ReferralRequest", "requester", element.getRequester(), -1); 10112 if (element.hasSpecialty()) 10113 composeCodeableConcept(t, "ReferralRequest", "specialty", element.getSpecialty(), -1); 10114 for (int i = 0; i < element.getRecipient().size(); i++) 10115 composeReference(t, "ReferralRequest", "recipient", element.getRecipient().get(i), i); 10116 if (element.hasReason()) 10117 composeCodeableConcept(t, "ReferralRequest", "reason", element.getReason(), -1); 10118 if (element.hasDescriptionElement()) 10119 composeString(t, "ReferralRequest", "description", element.getDescriptionElement(), -1); 10120 for (int i = 0; i < element.getServiceRequested().size(); i++) 10121 composeCodeableConcept(t, "ReferralRequest", "serviceRequested", element.getServiceRequested().get(i), i); 10122 for (int i = 0; i < element.getSupportingInformation().size(); i++) 10123 composeReference(t, "ReferralRequest", "supportingInformation", element.getSupportingInformation().get(i), i); 10124 } 10125 10126 protected void composeRelatedPerson(Complex parent, String parentType, String name, RelatedPerson element, int index) { 10127 if (element == null) 10128 return; 10129 Complex t; 10130 if (Utilities.noString(parentType)) 10131 t = parent; 10132 else { 10133 t = parent.predicate("fhir:"+parentType+'.'+name); 10134 } 10135 composeDomainResource(t, "RelatedPerson", name, element, index); 10136 for (int i = 0; i < element.getIdentifier().size(); i++) 10137 composeIdentifier(t, "RelatedPerson", "identifier", element.getIdentifier().get(i), i); 10138 if (element.hasPatient()) 10139 composeReference(t, "RelatedPerson", "patient", element.getPatient(), -1); 10140 if (element.hasRelationship()) 10141 composeCodeableConcept(t, "RelatedPerson", "relationship", element.getRelationship(), -1); 10142 if (element.hasName()) 10143 composeHumanName(t, "RelatedPerson", "name", element.getName(), -1); 10144 for (int i = 0; i < element.getTelecom().size(); i++) 10145 composeContactPoint(t, "RelatedPerson", "telecom", element.getTelecom().get(i), i); 10146 if (element.hasGenderElement()) 10147 composeEnum(t, "RelatedPerson", "gender", element.getGenderElement(), -1); 10148 if (element.hasBirthDateElement()) 10149 composeDate(t, "RelatedPerson", "birthDate", element.getBirthDateElement(), -1); 10150 for (int i = 0; i < element.getAddress().size(); i++) 10151 composeAddress(t, "RelatedPerson", "address", element.getAddress().get(i), i); 10152 for (int i = 0; i < element.getPhoto().size(); i++) 10153 composeAttachment(t, "RelatedPerson", "photo", element.getPhoto().get(i), i); 10154 if (element.hasPeriod()) 10155 composePeriod(t, "RelatedPerson", "period", element.getPeriod(), -1); 10156 } 10157 10158 protected void composeRiskAssessment(Complex parent, String parentType, String name, RiskAssessment element, int index) { 10159 if (element == null) 10160 return; 10161 Complex t; 10162 if (Utilities.noString(parentType)) 10163 t = parent; 10164 else { 10165 t = parent.predicate("fhir:"+parentType+'.'+name); 10166 } 10167 composeDomainResource(t, "RiskAssessment", name, element, index); 10168 if (element.hasSubject()) 10169 composeReference(t, "RiskAssessment", "subject", element.getSubject(), -1); 10170 if (element.hasDateElement()) 10171 composeDateTime(t, "RiskAssessment", "date", element.getDateElement(), -1); 10172 if (element.hasCondition()) 10173 composeReference(t, "RiskAssessment", "condition", element.getCondition(), -1); 10174 if (element.hasEncounter()) 10175 composeReference(t, "RiskAssessment", "encounter", element.getEncounter(), -1); 10176 if (element.hasPerformer()) 10177 composeReference(t, "RiskAssessment", "performer", element.getPerformer(), -1); 10178 if (element.hasIdentifier()) 10179 composeIdentifier(t, "RiskAssessment", "identifier", element.getIdentifier(), -1); 10180 if (element.hasMethod()) 10181 composeCodeableConcept(t, "RiskAssessment", "method", element.getMethod(), -1); 10182 for (int i = 0; i < element.getBasis().size(); i++) 10183 composeReference(t, "RiskAssessment", "basis", element.getBasis().get(i), i); 10184 for (int i = 0; i < element.getPrediction().size(); i++) 10185 composeRiskAssessmentRiskAssessmentPredictionComponent(t, "RiskAssessment", "prediction", element.getPrediction().get(i), i); 10186 if (element.hasMitigationElement()) 10187 composeString(t, "RiskAssessment", "mitigation", element.getMitigationElement(), -1); 10188 } 10189 10190 protected void composeRiskAssessmentRiskAssessmentPredictionComponent(Complex parent, String parentType, String name, RiskAssessment.RiskAssessmentPredictionComponent element, int index) { 10191 if (element == null) 10192 return; 10193 Complex t; 10194 if (Utilities.noString(parentType)) 10195 t = parent; 10196 else { 10197 t = parent.predicate("fhir:"+parentType+'.'+name); 10198 } 10199 composeBackboneElement(t, "prediction", name, element, index); 10200 if (element.hasOutcome()) 10201 composeCodeableConcept(t, "RiskAssessment", "outcome", element.getOutcome(), -1); 10202 if (element.hasProbability()) 10203 composeType(t, "RiskAssessment", "probability", element.getProbability(), -1); 10204 if (element.hasRelativeRiskElement()) 10205 composeDecimal(t, "RiskAssessment", "relativeRisk", element.getRelativeRiskElement(), -1); 10206 if (element.hasWhen()) 10207 composeType(t, "RiskAssessment", "when", element.getWhen(), -1); 10208 if (element.hasRationaleElement()) 10209 composeString(t, "RiskAssessment", "rationale", element.getRationaleElement(), -1); 10210 } 10211 10212 protected void composeSchedule(Complex parent, String parentType, String name, Schedule element, int index) { 10213 if (element == null) 10214 return; 10215 Complex t; 10216 if (Utilities.noString(parentType)) 10217 t = parent; 10218 else { 10219 t = parent.predicate("fhir:"+parentType+'.'+name); 10220 } 10221 composeDomainResource(t, "Schedule", name, element, index); 10222 for (int i = 0; i < element.getIdentifier().size(); i++) 10223 composeIdentifier(t, "Schedule", "identifier", element.getIdentifier().get(i), i); 10224 if (element.hasServiceCategory()) 10225 composeCodeableConcept(t, "Schedule", "serviceCategory", element.getServiceCategory(), -1); 10226 for (int i = 0; i < element.getServiceType().size(); i++) 10227 composeCodeableConcept(t, "Schedule", "serviceType", element.getServiceType().get(i), i); 10228 for (int i = 0; i < element.getSpecialty().size(); i++) 10229 composeCodeableConcept(t, "Schedule", "specialty", element.getSpecialty().get(i), i); 10230 if (element.hasActor()) 10231 composeReference(t, "Schedule", "actor", element.getActor(), -1); 10232 if (element.hasPlanningHorizon()) 10233 composePeriod(t, "Schedule", "planningHorizon", element.getPlanningHorizon(), -1); 10234 if (element.hasCommentElement()) 10235 composeString(t, "Schedule", "comment", element.getCommentElement(), -1); 10236 } 10237 10238 protected void composeSearchParameter(Complex parent, String parentType, String name, SearchParameter element, int index) { 10239 if (element == null) 10240 return; 10241 Complex t; 10242 if (Utilities.noString(parentType)) 10243 t = parent; 10244 else { 10245 t = parent.predicate("fhir:"+parentType+'.'+name); 10246 } 10247 composeDomainResource(t, "SearchParameter", name, element, index); 10248 if (element.hasUrlElement()) 10249 composeUri(t, "SearchParameter", "url", element.getUrlElement(), -1); 10250 if (element.hasNameElement()) 10251 composeString(t, "SearchParameter", "name", element.getNameElement(), -1); 10252 if (element.hasStatusElement()) 10253 composeEnum(t, "SearchParameter", "status", element.getStatusElement(), -1); 10254 if (element.hasExperimentalElement()) 10255 composeBoolean(t, "SearchParameter", "experimental", element.getExperimentalElement(), -1); 10256 if (element.hasDateElement()) 10257 composeDateTime(t, "SearchParameter", "date", element.getDateElement(), -1); 10258 if (element.hasPublisherElement()) 10259 composeString(t, "SearchParameter", "publisher", element.getPublisherElement(), -1); 10260 for (int i = 0; i < element.getContact().size(); i++) 10261 composeSearchParameterSearchParameterContactComponent(t, "SearchParameter", "contact", element.getContact().get(i), i); 10262 for (int i = 0; i < element.getUseContext().size(); i++) 10263 composeCodeableConcept(t, "SearchParameter", "useContext", element.getUseContext().get(i), i); 10264 if (element.hasRequirementsElement()) 10265 composeString(t, "SearchParameter", "requirements", element.getRequirementsElement(), -1); 10266 if (element.hasCodeElement()) 10267 composeCode(t, "SearchParameter", "code", element.getCodeElement(), -1); 10268 if (element.hasBaseElement()) 10269 composeCode(t, "SearchParameter", "base", element.getBaseElement(), -1); 10270 if (element.hasTypeElement()) 10271 composeEnum(t, "SearchParameter", "type", element.getTypeElement(), -1); 10272 if (element.hasDescriptionElement()) 10273 composeString(t, "SearchParameter", "description", element.getDescriptionElement(), -1); 10274 if (element.hasExpressionElement()) 10275 composeString(t, "SearchParameter", "expression", element.getExpressionElement(), -1); 10276 if (element.hasXpathElement()) 10277 composeString(t, "SearchParameter", "xpath", element.getXpathElement(), -1); 10278 if (element.hasXpathUsageElement()) 10279 composeEnum(t, "SearchParameter", "xpathUsage", element.getXpathUsageElement(), -1); 10280 for (int i = 0; i < element.getTarget().size(); i++) 10281 composeCode(t, "SearchParameter", "target", element.getTarget().get(i), i); 10282 } 10283 10284 protected void composeSearchParameterSearchParameterContactComponent(Complex parent, String parentType, String name, SearchParameter.SearchParameterContactComponent element, int index) { 10285 if (element == null) 10286 return; 10287 Complex t; 10288 if (Utilities.noString(parentType)) 10289 t = parent; 10290 else { 10291 t = parent.predicate("fhir:"+parentType+'.'+name); 10292 } 10293 composeBackboneElement(t, "contact", name, element, index); 10294 if (element.hasNameElement()) 10295 composeString(t, "SearchParameter", "name", element.getNameElement(), -1); 10296 for (int i = 0; i < element.getTelecom().size(); i++) 10297 composeContactPoint(t, "SearchParameter", "telecom", element.getTelecom().get(i), i); 10298 } 10299 10300 protected void composeSequence(Complex parent, String parentType, String name, Sequence element, int index) { 10301 if (element == null) 10302 return; 10303 Complex t; 10304 if (Utilities.noString(parentType)) 10305 t = parent; 10306 else { 10307 t = parent.predicate("fhir:"+parentType+'.'+name); 10308 } 10309 composeDomainResource(t, "Sequence", name, element, index); 10310 if (element.hasTypeElement()) 10311 composeEnum(t, "Sequence", "type", element.getTypeElement(), -1); 10312 if (element.hasPatient()) 10313 composeReference(t, "Sequence", "patient", element.getPatient(), -1); 10314 if (element.hasSpecimen()) 10315 composeReference(t, "Sequence", "specimen", element.getSpecimen(), -1); 10316 if (element.hasDevice()) 10317 composeReference(t, "Sequence", "device", element.getDevice(), -1); 10318 if (element.hasQuantity()) 10319 composeQuantity(t, "Sequence", "quantity", element.getQuantity(), -1); 10320 if (element.hasSpecies()) 10321 composeCodeableConcept(t, "Sequence", "species", element.getSpecies(), -1); 10322 for (int i = 0; i < element.getReferenceSeq().size(); i++) 10323 composeSequenceSequenceReferenceSeqComponent(t, "Sequence", "referenceSeq", element.getReferenceSeq().get(i), i); 10324 if (element.hasVariation()) 10325 composeSequenceSequenceVariationComponent(t, "Sequence", "variation", element.getVariation(), -1); 10326 for (int i = 0; i < element.getQuality().size(); i++) 10327 composeSequenceSequenceQualityComponent(t, "Sequence", "quality", element.getQuality().get(i), i); 10328 if (element.hasAllelicState()) 10329 composeCodeableConcept(t, "Sequence", "allelicState", element.getAllelicState(), -1); 10330 if (element.hasAllelicFrequencyElement()) 10331 composeDecimal(t, "Sequence", "allelicFrequency", element.getAllelicFrequencyElement(), -1); 10332 if (element.hasCopyNumberEvent()) 10333 composeCodeableConcept(t, "Sequence", "copyNumberEvent", element.getCopyNumberEvent(), -1); 10334 if (element.hasReadCoverageElement()) 10335 composeInteger(t, "Sequence", "readCoverage", element.getReadCoverageElement(), -1); 10336 for (int i = 0; i < element.getRepository().size(); i++) 10337 composeSequenceSequenceRepositoryComponent(t, "Sequence", "repository", element.getRepository().get(i), i); 10338 for (int i = 0; i < element.getPointer().size(); i++) 10339 composeReference(t, "Sequence", "pointer", element.getPointer().get(i), i); 10340 if (element.hasObservedSeqElement()) 10341 composeString(t, "Sequence", "observedSeq", element.getObservedSeqElement(), -1); 10342 if (element.hasObservation()) 10343 composeReference(t, "Sequence", "observation", element.getObservation(), -1); 10344 if (element.hasStructureVariation()) 10345 composeSequenceSequenceStructureVariationComponent(t, "Sequence", "structureVariation", element.getStructureVariation(), -1); 10346 } 10347 10348 protected void composeSequenceSequenceReferenceSeqComponent(Complex parent, String parentType, String name, Sequence.SequenceReferenceSeqComponent element, int index) { 10349 if (element == null) 10350 return; 10351 Complex t; 10352 if (Utilities.noString(parentType)) 10353 t = parent; 10354 else { 10355 t = parent.predicate("fhir:"+parentType+'.'+name); 10356 } 10357 composeBackboneElement(t, "referenceSeq", name, element, index); 10358 if (element.hasChromosome()) 10359 composeCodeableConcept(t, "Sequence", "chromosome", element.getChromosome(), -1); 10360 if (element.hasGenomeBuildElement()) 10361 composeString(t, "Sequence", "genomeBuild", element.getGenomeBuildElement(), -1); 10362 if (element.hasReferenceSeqId()) 10363 composeCodeableConcept(t, "Sequence", "referenceSeqId", element.getReferenceSeqId(), -1); 10364 if (element.hasReferenceSeqPointer()) 10365 composeReference(t, "Sequence", "referenceSeqPointer", element.getReferenceSeqPointer(), -1); 10366 if (element.hasReferenceSeqStringElement()) 10367 composeString(t, "Sequence", "referenceSeqString", element.getReferenceSeqStringElement(), -1); 10368 if (element.hasWindowStartElement()) 10369 composeInteger(t, "Sequence", "windowStart", element.getWindowStartElement(), -1); 10370 if (element.hasWindowEndElement()) 10371 composeInteger(t, "Sequence", "windowEnd", element.getWindowEndElement(), -1); 10372 } 10373 10374 protected void composeSequenceSequenceVariationComponent(Complex parent, String parentType, String name, Sequence.SequenceVariationComponent element, int index) { 10375 if (element == null) 10376 return; 10377 Complex t; 10378 if (Utilities.noString(parentType)) 10379 t = parent; 10380 else { 10381 t = parent.predicate("fhir:"+parentType+'.'+name); 10382 } 10383 composeBackboneElement(t, "variation", name, element, index); 10384 if (element.hasStartElement()) 10385 composeInteger(t, "Sequence", "start", element.getStartElement(), -1); 10386 if (element.hasEndElement()) 10387 composeInteger(t, "Sequence", "end", element.getEndElement(), -1); 10388 if (element.hasObservedAlleleElement()) 10389 composeString(t, "Sequence", "observedAllele", element.getObservedAlleleElement(), -1); 10390 if (element.hasReferenceAlleleElement()) 10391 composeString(t, "Sequence", "referenceAllele", element.getReferenceAlleleElement(), -1); 10392 if (element.hasCigarElement()) 10393 composeString(t, "Sequence", "cigar", element.getCigarElement(), -1); 10394 } 10395 10396 protected void composeSequenceSequenceQualityComponent(Complex parent, String parentType, String name, Sequence.SequenceQualityComponent element, int index) { 10397 if (element == null) 10398 return; 10399 Complex t; 10400 if (Utilities.noString(parentType)) 10401 t = parent; 10402 else { 10403 t = parent.predicate("fhir:"+parentType+'.'+name); 10404 } 10405 composeBackboneElement(t, "quality", name, element, index); 10406 if (element.hasStartElement()) 10407 composeInteger(t, "Sequence", "start", element.getStartElement(), -1); 10408 if (element.hasEndElement()) 10409 composeInteger(t, "Sequence", "end", element.getEndElement(), -1); 10410 if (element.hasScore()) 10411 composeQuantity(t, "Sequence", "score", element.getScore(), -1); 10412 if (element.hasMethodElement()) 10413 composeString(t, "Sequence", "method", element.getMethodElement(), -1); 10414 } 10415 10416 protected void composeSequenceSequenceRepositoryComponent(Complex parent, String parentType, String name, Sequence.SequenceRepositoryComponent element, int index) { 10417 if (element == null) 10418 return; 10419 Complex t; 10420 if (Utilities.noString(parentType)) 10421 t = parent; 10422 else { 10423 t = parent.predicate("fhir:"+parentType+'.'+name); 10424 } 10425 composeBackboneElement(t, "repository", name, element, index); 10426 if (element.hasUrlElement()) 10427 composeUri(t, "Sequence", "url", element.getUrlElement(), -1); 10428 if (element.hasNameElement()) 10429 composeString(t, "Sequence", "name", element.getNameElement(), -1); 10430 if (element.hasVariantIdElement()) 10431 composeString(t, "Sequence", "variantId", element.getVariantIdElement(), -1); 10432 if (element.hasReadIdElement()) 10433 composeString(t, "Sequence", "readId", element.getReadIdElement(), -1); 10434 } 10435 10436 protected void composeSequenceSequenceStructureVariationComponent(Complex parent, String parentType, String name, Sequence.SequenceStructureVariationComponent element, int index) { 10437 if (element == null) 10438 return; 10439 Complex t; 10440 if (Utilities.noString(parentType)) 10441 t = parent; 10442 else { 10443 t = parent.predicate("fhir:"+parentType+'.'+name); 10444 } 10445 composeBackboneElement(t, "structureVariation", name, element, index); 10446 if (element.hasPrecisionOfBoundariesElement()) 10447 composeString(t, "Sequence", "precisionOfBoundaries", element.getPrecisionOfBoundariesElement(), -1); 10448 if (element.hasReportedaCGHRatioElement()) 10449 composeDecimal(t, "Sequence", "reportedaCGHRatio", element.getReportedaCGHRatioElement(), -1); 10450 if (element.hasLengthElement()) 10451 composeInteger(t, "Sequence", "length", element.getLengthElement(), -1); 10452 if (element.hasOuter()) 10453 composeSequenceSequenceStructureVariationOuterComponent(t, "Sequence", "outer", element.getOuter(), -1); 10454 if (element.hasInner()) 10455 composeSequenceSequenceStructureVariationInnerComponent(t, "Sequence", "inner", element.getInner(), -1); 10456 } 10457 10458 protected void composeSequenceSequenceStructureVariationOuterComponent(Complex parent, String parentType, String name, Sequence.SequenceStructureVariationOuterComponent element, int index) { 10459 if (element == null) 10460 return; 10461 Complex t; 10462 if (Utilities.noString(parentType)) 10463 t = parent; 10464 else { 10465 t = parent.predicate("fhir:"+parentType+'.'+name); 10466 } 10467 composeBackboneElement(t, "outer", name, element, index); 10468 if (element.hasStartElement()) 10469 composeInteger(t, "Sequence", "start", element.getStartElement(), -1); 10470 if (element.hasEndElement()) 10471 composeInteger(t, "Sequence", "end", element.getEndElement(), -1); 10472 } 10473 10474 protected void composeSequenceSequenceStructureVariationInnerComponent(Complex parent, String parentType, String name, Sequence.SequenceStructureVariationInnerComponent element, int index) { 10475 if (element == null) 10476 return; 10477 Complex t; 10478 if (Utilities.noString(parentType)) 10479 t = parent; 10480 else { 10481 t = parent.predicate("fhir:"+parentType+'.'+name); 10482 } 10483 composeBackboneElement(t, "inner", name, element, index); 10484 if (element.hasStartElement()) 10485 composeInteger(t, "Sequence", "start", element.getStartElement(), -1); 10486 if (element.hasEndElement()) 10487 composeInteger(t, "Sequence", "end", element.getEndElement(), -1); 10488 } 10489 10490 protected void composeSlot(Complex parent, String parentType, String name, Slot element, int index) { 10491 if (element == null) 10492 return; 10493 Complex t; 10494 if (Utilities.noString(parentType)) 10495 t = parent; 10496 else { 10497 t = parent.predicate("fhir:"+parentType+'.'+name); 10498 } 10499 composeDomainResource(t, "Slot", name, element, index); 10500 for (int i = 0; i < element.getIdentifier().size(); i++) 10501 composeIdentifier(t, "Slot", "identifier", element.getIdentifier().get(i), i); 10502 if (element.hasServiceCategory()) 10503 composeCodeableConcept(t, "Slot", "serviceCategory", element.getServiceCategory(), -1); 10504 for (int i = 0; i < element.getServiceType().size(); i++) 10505 composeCodeableConcept(t, "Slot", "serviceType", element.getServiceType().get(i), i); 10506 for (int i = 0; i < element.getSpecialty().size(); i++) 10507 composeCodeableConcept(t, "Slot", "specialty", element.getSpecialty().get(i), i); 10508 if (element.hasAppointmentType()) 10509 composeCodeableConcept(t, "Slot", "appointmentType", element.getAppointmentType(), -1); 10510 if (element.hasSchedule()) 10511 composeReference(t, "Slot", "schedule", element.getSchedule(), -1); 10512 if (element.hasStatusElement()) 10513 composeEnum(t, "Slot", "status", element.getStatusElement(), -1); 10514 if (element.hasStartElement()) 10515 composeInstant(t, "Slot", "start", element.getStartElement(), -1); 10516 if (element.hasEndElement()) 10517 composeInstant(t, "Slot", "end", element.getEndElement(), -1); 10518 if (element.hasOverbookedElement()) 10519 composeBoolean(t, "Slot", "overbooked", element.getOverbookedElement(), -1); 10520 if (element.hasCommentElement()) 10521 composeString(t, "Slot", "comment", element.getCommentElement(), -1); 10522 } 10523 10524 protected void composeSpecimen(Complex parent, String parentType, String name, Specimen element, int index) { 10525 if (element == null) 10526 return; 10527 Complex t; 10528 if (Utilities.noString(parentType)) 10529 t = parent; 10530 else { 10531 t = parent.predicate("fhir:"+parentType+'.'+name); 10532 } 10533 composeDomainResource(t, "Specimen", name, element, index); 10534 for (int i = 0; i < element.getIdentifier().size(); i++) 10535 composeIdentifier(t, "Specimen", "identifier", element.getIdentifier().get(i), i); 10536 if (element.hasAccessionIdentifier()) 10537 composeIdentifier(t, "Specimen", "accessionIdentifier", element.getAccessionIdentifier(), -1); 10538 if (element.hasStatusElement()) 10539 composeEnum(t, "Specimen", "status", element.getStatusElement(), -1); 10540 if (element.hasType()) 10541 composeCodeableConcept(t, "Specimen", "type", element.getType(), -1); 10542 if (element.hasSubject()) 10543 composeReference(t, "Specimen", "subject", element.getSubject(), -1); 10544 if (element.hasReceivedTimeElement()) 10545 composeDateTime(t, "Specimen", "receivedTime", element.getReceivedTimeElement(), -1); 10546 for (int i = 0; i < element.getParent().size(); i++) 10547 composeReference(t, "Specimen", "parent", element.getParent().get(i), i); 10548 if (element.hasCollection()) 10549 composeSpecimenSpecimenCollectionComponent(t, "Specimen", "collection", element.getCollection(), -1); 10550 for (int i = 0; i < element.getTreatment().size(); i++) 10551 composeSpecimenSpecimenTreatmentComponent(t, "Specimen", "treatment", element.getTreatment().get(i), i); 10552 for (int i = 0; i < element.getContainer().size(); i++) 10553 composeSpecimenSpecimenContainerComponent(t, "Specimen", "container", element.getContainer().get(i), i); 10554 } 10555 10556 protected void composeSpecimenSpecimenCollectionComponent(Complex parent, String parentType, String name, Specimen.SpecimenCollectionComponent element, int index) { 10557 if (element == null) 10558 return; 10559 Complex t; 10560 if (Utilities.noString(parentType)) 10561 t = parent; 10562 else { 10563 t = parent.predicate("fhir:"+parentType+'.'+name); 10564 } 10565 composeBackboneElement(t, "collection", name, element, index); 10566 if (element.hasCollector()) 10567 composeReference(t, "Specimen", "collector", element.getCollector(), -1); 10568 if (element.hasCommentElement()) 10569 composeString(t, "Specimen", "comment", element.getCommentElement(), -1); 10570 if (element.hasCollected()) 10571 composeType(t, "Specimen", "collected", element.getCollected(), -1); 10572 if (element.hasQuantity()) 10573 composeQuantity(t, "Specimen", "quantity", element.getQuantity(), -1); 10574 if (element.hasMethod()) 10575 composeCodeableConcept(t, "Specimen", "method", element.getMethod(), -1); 10576 if (element.hasBodySite()) 10577 composeCodeableConcept(t, "Specimen", "bodySite", element.getBodySite(), -1); 10578 } 10579 10580 protected void composeSpecimenSpecimenTreatmentComponent(Complex parent, String parentType, String name, Specimen.SpecimenTreatmentComponent element, int index) { 10581 if (element == null) 10582 return; 10583 Complex t; 10584 if (Utilities.noString(parentType)) 10585 t = parent; 10586 else { 10587 t = parent.predicate("fhir:"+parentType+'.'+name); 10588 } 10589 composeBackboneElement(t, "treatment", name, element, index); 10590 if (element.hasDescriptionElement()) 10591 composeString(t, "Specimen", "description", element.getDescriptionElement(), -1); 10592 if (element.hasProcedure()) 10593 composeCodeableConcept(t, "Specimen", "procedure", element.getProcedure(), -1); 10594 for (int i = 0; i < element.getAdditive().size(); i++) 10595 composeReference(t, "Specimen", "additive", element.getAdditive().get(i), i); 10596 } 10597 10598 protected void composeSpecimenSpecimenContainerComponent(Complex parent, String parentType, String name, Specimen.SpecimenContainerComponent element, int index) { 10599 if (element == null) 10600 return; 10601 Complex t; 10602 if (Utilities.noString(parentType)) 10603 t = parent; 10604 else { 10605 t = parent.predicate("fhir:"+parentType+'.'+name); 10606 } 10607 composeBackboneElement(t, "container", name, element, index); 10608 for (int i = 0; i < element.getIdentifier().size(); i++) 10609 composeIdentifier(t, "Specimen", "identifier", element.getIdentifier().get(i), i); 10610 if (element.hasDescriptionElement()) 10611 composeString(t, "Specimen", "description", element.getDescriptionElement(), -1); 10612 if (element.hasType()) 10613 composeCodeableConcept(t, "Specimen", "type", element.getType(), -1); 10614 if (element.hasCapacity()) 10615 composeQuantity(t, "Specimen", "capacity", element.getCapacity(), -1); 10616 if (element.hasSpecimenQuantity()) 10617 composeQuantity(t, "Specimen", "specimenQuantity", element.getSpecimenQuantity(), -1); 10618 if (element.hasAdditive()) 10619 composeType(t, "Specimen", "additive", element.getAdditive(), -1); 10620 } 10621 10622 protected void composeStructureDefinition(Complex parent, String parentType, String name, StructureDefinition element, int index) { 10623 if (element == null) 10624 return; 10625 Complex t; 10626 if (Utilities.noString(parentType)) 10627 t = parent; 10628 else { 10629 t = parent.predicate("fhir:"+parentType+'.'+name); 10630 } 10631 composeDomainResource(t, "StructureDefinition", name, element, index); 10632 if (element.hasUrlElement()) 10633 composeUri(t, "StructureDefinition", "url", element.getUrlElement(), -1); 10634 for (int i = 0; i < element.getIdentifier().size(); i++) 10635 composeIdentifier(t, "StructureDefinition", "identifier", element.getIdentifier().get(i), i); 10636 if (element.hasVersionElement()) 10637 composeString(t, "StructureDefinition", "version", element.getVersionElement(), -1); 10638 if (element.hasNameElement()) 10639 composeString(t, "StructureDefinition", "name", element.getNameElement(), -1); 10640 if (element.hasDisplayElement()) 10641 composeString(t, "StructureDefinition", "display", element.getDisplayElement(), -1); 10642 if (element.hasStatusElement()) 10643 composeEnum(t, "StructureDefinition", "status", element.getStatusElement(), -1); 10644 if (element.hasExperimentalElement()) 10645 composeBoolean(t, "StructureDefinition", "experimental", element.getExperimentalElement(), -1); 10646 if (element.hasPublisherElement()) 10647 composeString(t, "StructureDefinition", "publisher", element.getPublisherElement(), -1); 10648 for (int i = 0; i < element.getContact().size(); i++) 10649 composeStructureDefinitionStructureDefinitionContactComponent(t, "StructureDefinition", "contact", element.getContact().get(i), i); 10650 if (element.hasDateElement()) 10651 composeDateTime(t, "StructureDefinition", "date", element.getDateElement(), -1); 10652 if (element.hasDescriptionElement()) 10653 composeString(t, "StructureDefinition", "description", element.getDescriptionElement(), -1); 10654 for (int i = 0; i < element.getUseContext().size(); i++) 10655 composeCodeableConcept(t, "StructureDefinition", "useContext", element.getUseContext().get(i), i); 10656 if (element.hasRequirementsElement()) 10657 composeString(t, "StructureDefinition", "requirements", element.getRequirementsElement(), -1); 10658 if (element.hasCopyrightElement()) 10659 composeString(t, "StructureDefinition", "copyright", element.getCopyrightElement(), -1); 10660 for (int i = 0; i < element.getCode().size(); i++) 10661 composeCoding(t, "StructureDefinition", "code", element.getCode().get(i), i); 10662 if (element.hasFhirVersionElement()) 10663 composeId(t, "StructureDefinition", "fhirVersion", element.getFhirVersionElement(), -1); 10664 for (int i = 0; i < element.getMapping().size(); i++) 10665 composeStructureDefinitionStructureDefinitionMappingComponent(t, "StructureDefinition", "mapping", element.getMapping().get(i), i); 10666 if (element.hasKindElement()) 10667 composeEnum(t, "StructureDefinition", "kind", element.getKindElement(), -1); 10668 if (element.hasAbstractElement()) 10669 composeBoolean(t, "StructureDefinition", "abstract", element.getAbstractElement(), -1); 10670 if (element.hasContextTypeElement()) 10671 composeEnum(t, "StructureDefinition", "contextType", element.getContextTypeElement(), -1); 10672 for (int i = 0; i < element.getContext().size(); i++) 10673 composeString(t, "StructureDefinition", "context", element.getContext().get(i), i); 10674 if (element.hasBaseTypeElement()) 10675 composeCode(t, "StructureDefinition", "baseType", element.getBaseTypeElement(), -1); 10676 if (element.hasBaseDefinitionElement()) 10677 composeUri(t, "StructureDefinition", "baseDefinition", element.getBaseDefinitionElement(), -1); 10678 if (element.hasDerivationElement()) 10679 composeEnum(t, "StructureDefinition", "derivation", element.getDerivationElement(), -1); 10680 if (element.hasSnapshot()) 10681 composeStructureDefinitionStructureDefinitionSnapshotComponent(t, "StructureDefinition", "snapshot", element.getSnapshot(), -1); 10682 if (element.hasDifferential()) 10683 composeStructureDefinitionStructureDefinitionDifferentialComponent(t, "StructureDefinition", "differential", element.getDifferential(), -1); 10684 } 10685 10686 protected void composeStructureDefinitionStructureDefinitionContactComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionContactComponent element, int index) { 10687 if (element == null) 10688 return; 10689 Complex t; 10690 if (Utilities.noString(parentType)) 10691 t = parent; 10692 else { 10693 t = parent.predicate("fhir:"+parentType+'.'+name); 10694 } 10695 composeBackboneElement(t, "contact", name, element, index); 10696 if (element.hasNameElement()) 10697 composeString(t, "StructureDefinition", "name", element.getNameElement(), -1); 10698 for (int i = 0; i < element.getTelecom().size(); i++) 10699 composeContactPoint(t, "StructureDefinition", "telecom", element.getTelecom().get(i), i); 10700 } 10701 10702 protected void composeStructureDefinitionStructureDefinitionMappingComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionMappingComponent element, int index) { 10703 if (element == null) 10704 return; 10705 Complex t; 10706 if (Utilities.noString(parentType)) 10707 t = parent; 10708 else { 10709 t = parent.predicate("fhir:"+parentType+'.'+name); 10710 } 10711 composeBackboneElement(t, "mapping", name, element, index); 10712 if (element.hasIdentityElement()) 10713 composeId(t, "StructureDefinition", "identity", element.getIdentityElement(), -1); 10714 if (element.hasUriElement()) 10715 composeUri(t, "StructureDefinition", "uri", element.getUriElement(), -1); 10716 if (element.hasNameElement()) 10717 composeString(t, "StructureDefinition", "name", element.getNameElement(), -1); 10718 if (element.hasCommentsElement()) 10719 composeString(t, "StructureDefinition", "comments", element.getCommentsElement(), -1); 10720 } 10721 10722 protected void composeStructureDefinitionStructureDefinitionSnapshotComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionSnapshotComponent element, int index) { 10723 if (element == null) 10724 return; 10725 Complex t; 10726 if (Utilities.noString(parentType)) 10727 t = parent; 10728 else { 10729 t = parent.predicate("fhir:"+parentType+'.'+name); 10730 } 10731 composeBackboneElement(t, "snapshot", name, element, index); 10732 for (int i = 0; i < element.getElement().size(); i++) 10733 composeElementDefinition(t, "StructureDefinition", "element", element.getElement().get(i), i); 10734 } 10735 10736 protected void composeStructureDefinitionStructureDefinitionDifferentialComponent(Complex parent, String parentType, String name, StructureDefinition.StructureDefinitionDifferentialComponent element, int index) { 10737 if (element == null) 10738 return; 10739 Complex t; 10740 if (Utilities.noString(parentType)) 10741 t = parent; 10742 else { 10743 t = parent.predicate("fhir:"+parentType+'.'+name); 10744 } 10745 composeBackboneElement(t, "differential", name, element, index); 10746 for (int i = 0; i < element.getElement().size(); i++) 10747 composeElementDefinition(t, "StructureDefinition", "element", element.getElement().get(i), i); 10748 } 10749 10750 protected void composeStructureMap(Complex parent, String parentType, String name, StructureMap element, int index) { 10751 if (element == null) 10752 return; 10753 Complex t; 10754 if (Utilities.noString(parentType)) 10755 t = parent; 10756 else { 10757 t = parent.predicate("fhir:"+parentType+'.'+name); 10758 } 10759 composeDomainResource(t, "StructureMap", name, element, index); 10760 if (element.hasUrlElement()) 10761 composeUri(t, "StructureMap", "url", element.getUrlElement(), -1); 10762 for (int i = 0; i < element.getIdentifier().size(); i++) 10763 composeIdentifier(t, "StructureMap", "identifier", element.getIdentifier().get(i), i); 10764 if (element.hasVersionElement()) 10765 composeString(t, "StructureMap", "version", element.getVersionElement(), -1); 10766 if (element.hasNameElement()) 10767 composeString(t, "StructureMap", "name", element.getNameElement(), -1); 10768 if (element.hasStatusElement()) 10769 composeEnum(t, "StructureMap", "status", element.getStatusElement(), -1); 10770 if (element.hasExperimentalElement()) 10771 composeBoolean(t, "StructureMap", "experimental", element.getExperimentalElement(), -1); 10772 if (element.hasPublisherElement()) 10773 composeString(t, "StructureMap", "publisher", element.getPublisherElement(), -1); 10774 for (int i = 0; i < element.getContact().size(); i++) 10775 composeStructureMapStructureMapContactComponent(t, "StructureMap", "contact", element.getContact().get(i), i); 10776 if (element.hasDateElement()) 10777 composeDateTime(t, "StructureMap", "date", element.getDateElement(), -1); 10778 if (element.hasDescriptionElement()) 10779 composeString(t, "StructureMap", "description", element.getDescriptionElement(), -1); 10780 for (int i = 0; i < element.getUseContext().size(); i++) 10781 composeCodeableConcept(t, "StructureMap", "useContext", element.getUseContext().get(i), i); 10782 if (element.hasRequirementsElement()) 10783 composeString(t, "StructureMap", "requirements", element.getRequirementsElement(), -1); 10784 if (element.hasCopyrightElement()) 10785 composeString(t, "StructureMap", "copyright", element.getCopyrightElement(), -1); 10786 for (int i = 0; i < element.getStructure().size(); i++) 10787 composeStructureMapStructureMapStructureComponent(t, "StructureMap", "structure", element.getStructure().get(i), i); 10788 for (int i = 0; i < element.getImport().size(); i++) 10789 composeUri(t, "StructureMap", "import", element.getImport().get(i), i); 10790 for (int i = 0; i < element.getGroup().size(); i++) 10791 composeStructureMapStructureMapGroupComponent(t, "StructureMap", "group", element.getGroup().get(i), i); 10792 } 10793 10794 protected void composeStructureMapStructureMapContactComponent(Complex parent, String parentType, String name, StructureMap.StructureMapContactComponent element, int index) { 10795 if (element == null) 10796 return; 10797 Complex t; 10798 if (Utilities.noString(parentType)) 10799 t = parent; 10800 else { 10801 t = parent.predicate("fhir:"+parentType+'.'+name); 10802 } 10803 composeBackboneElement(t, "contact", name, element, index); 10804 if (element.hasNameElement()) 10805 composeString(t, "StructureMap", "name", element.getNameElement(), -1); 10806 for (int i = 0; i < element.getTelecom().size(); i++) 10807 composeContactPoint(t, "StructureMap", "telecom", element.getTelecom().get(i), i); 10808 } 10809 10810 protected void composeStructureMapStructureMapStructureComponent(Complex parent, String parentType, String name, StructureMap.StructureMapStructureComponent element, int index) { 10811 if (element == null) 10812 return; 10813 Complex t; 10814 if (Utilities.noString(parentType)) 10815 t = parent; 10816 else { 10817 t = parent.predicate("fhir:"+parentType+'.'+name); 10818 } 10819 composeBackboneElement(t, "structure", name, element, index); 10820 if (element.hasUrlElement()) 10821 composeUri(t, "StructureMap", "url", element.getUrlElement(), -1); 10822 if (element.hasModeElement()) 10823 composeEnum(t, "StructureMap", "mode", element.getModeElement(), -1); 10824 if (element.hasDocumentationElement()) 10825 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 10826 } 10827 10828 protected void composeStructureMapStructureMapGroupComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupComponent element, int index) { 10829 if (element == null) 10830 return; 10831 Complex t; 10832 if (Utilities.noString(parentType)) 10833 t = parent; 10834 else { 10835 t = parent.predicate("fhir:"+parentType+'.'+name); 10836 } 10837 composeBackboneElement(t, "group", name, element, index); 10838 if (element.hasNameElement()) 10839 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 10840 if (element.hasExtendsElement()) 10841 composeId(t, "StructureMap", "extends", element.getExtendsElement(), -1); 10842 if (element.hasDocumentationElement()) 10843 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 10844 for (int i = 0; i < element.getInput().size(); i++) 10845 composeStructureMapStructureMapGroupInputComponent(t, "StructureMap", "input", element.getInput().get(i), i); 10846 for (int i = 0; i < element.getRule().size(); i++) 10847 composeStructureMapStructureMapGroupRuleComponent(t, "StructureMap", "rule", element.getRule().get(i), i); 10848 } 10849 10850 protected void composeStructureMapStructureMapGroupInputComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupInputComponent element, int index) { 10851 if (element == null) 10852 return; 10853 Complex t; 10854 if (Utilities.noString(parentType)) 10855 t = parent; 10856 else { 10857 t = parent.predicate("fhir:"+parentType+'.'+name); 10858 } 10859 composeBackboneElement(t, "input", name, element, index); 10860 if (element.hasNameElement()) 10861 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 10862 if (element.hasTypeElement()) 10863 composeString(t, "StructureMap", "type", element.getTypeElement(), -1); 10864 if (element.hasModeElement()) 10865 composeEnum(t, "StructureMap", "mode", element.getModeElement(), -1); 10866 if (element.hasDocumentationElement()) 10867 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 10868 } 10869 10870 protected void composeStructureMapStructureMapGroupRuleComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleComponent element, int index) { 10871 if (element == null) 10872 return; 10873 Complex t; 10874 if (Utilities.noString(parentType)) 10875 t = parent; 10876 else { 10877 t = parent.predicate("fhir:"+parentType+'.'+name); 10878 } 10879 composeBackboneElement(t, "rule", name, element, index); 10880 if (element.hasNameElement()) 10881 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 10882 for (int i = 0; i < element.getSource().size(); i++) 10883 composeStructureMapStructureMapGroupRuleSourceComponent(t, "StructureMap", "source", element.getSource().get(i), i); 10884 for (int i = 0; i < element.getTarget().size(); i++) 10885 composeStructureMapStructureMapGroupRuleTargetComponent(t, "StructureMap", "target", element.getTarget().get(i), i); 10886 for (int i = 0; i < element.getRule().size(); i++) 10887 composeStructureMapStructureMapGroupRuleComponent(t, "StructureMap", "rule", element.getRule().get(i), i); 10888 for (int i = 0; i < element.getDependent().size(); i++) 10889 composeStructureMapStructureMapGroupRuleDependentComponent(t, "StructureMap", "dependent", element.getDependent().get(i), i); 10890 if (element.hasDocumentationElement()) 10891 composeString(t, "StructureMap", "documentation", element.getDocumentationElement(), -1); 10892 } 10893 10894 protected void composeStructureMapStructureMapGroupRuleSourceComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleSourceComponent element, int index) { 10895 if (element == null) 10896 return; 10897 Complex t; 10898 if (Utilities.noString(parentType)) 10899 t = parent; 10900 else { 10901 t = parent.predicate("fhir:"+parentType+'.'+name); 10902 } 10903 composeBackboneElement(t, "source", name, element, index); 10904 if (element.hasRequiredElement()) 10905 composeBoolean(t, "StructureMap", "required", element.getRequiredElement(), -1); 10906 if (element.hasContextElement()) 10907 composeId(t, "StructureMap", "context", element.getContextElement(), -1); 10908 if (element.hasContextTypeElement()) 10909 composeEnum(t, "StructureMap", "contextType", element.getContextTypeElement(), -1); 10910 if (element.hasElementElement()) 10911 composeString(t, "StructureMap", "element", element.getElementElement(), -1); 10912 if (element.hasListModeElement()) 10913 composeEnum(t, "StructureMap", "listMode", element.getListModeElement(), -1); 10914 if (element.hasVariableElement()) 10915 composeId(t, "StructureMap", "variable", element.getVariableElement(), -1); 10916 if (element.hasConditionElement()) 10917 composeString(t, "StructureMap", "condition", element.getConditionElement(), -1); 10918 if (element.hasCheckElement()) 10919 composeString(t, "StructureMap", "check", element.getCheckElement(), -1); 10920 } 10921 10922 protected void composeStructureMapStructureMapGroupRuleTargetComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetComponent element, int index) { 10923 if (element == null) 10924 return; 10925 Complex t; 10926 if (Utilities.noString(parentType)) 10927 t = parent; 10928 else { 10929 t = parent.predicate("fhir:"+parentType+'.'+name); 10930 } 10931 composeBackboneElement(t, "target", name, element, index); 10932 if (element.hasContextElement()) 10933 composeId(t, "StructureMap", "context", element.getContextElement(), -1); 10934 if (element.hasContextTypeElement()) 10935 composeEnum(t, "StructureMap", "contextType", element.getContextTypeElement(), -1); 10936 if (element.hasElementElement()) 10937 composeString(t, "StructureMap", "element", element.getElementElement(), -1); 10938 if (element.hasVariableElement()) 10939 composeId(t, "StructureMap", "variable", element.getVariableElement(), -1); 10940 for (int i = 0; i < element.getListMode().size(); i++) 10941 composeEnum(t, "StructureMap", "listMode", element.getListMode().get(i), i); 10942 if (element.hasListRuleIdElement()) 10943 composeId(t, "StructureMap", "listRuleId", element.getListRuleIdElement(), -1); 10944 if (element.hasTransformElement()) 10945 composeEnum(t, "StructureMap", "transform", element.getTransformElement(), -1); 10946 for (int i = 0; i < element.getParameter().size(); i++) 10947 composeStructureMapStructureMapGroupRuleTargetParameterComponent(t, "StructureMap", "parameter", element.getParameter().get(i), i); 10948 } 10949 10950 protected void composeStructureMapStructureMapGroupRuleTargetParameterComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleTargetParameterComponent element, int index) { 10951 if (element == null) 10952 return; 10953 Complex t; 10954 if (Utilities.noString(parentType)) 10955 t = parent; 10956 else { 10957 t = parent.predicate("fhir:"+parentType+'.'+name); 10958 } 10959 composeBackboneElement(t, "parameter", name, element, index); 10960 if (element.hasValue()) 10961 composeType(t, "StructureMap", "value", element.getValue(), -1); 10962 } 10963 10964 protected void composeStructureMapStructureMapGroupRuleDependentComponent(Complex parent, String parentType, String name, StructureMap.StructureMapGroupRuleDependentComponent element, int index) { 10965 if (element == null) 10966 return; 10967 Complex t; 10968 if (Utilities.noString(parentType)) 10969 t = parent; 10970 else { 10971 t = parent.predicate("fhir:"+parentType+'.'+name); 10972 } 10973 composeBackboneElement(t, "dependent", name, element, index); 10974 if (element.hasNameElement()) 10975 composeId(t, "StructureMap", "name", element.getNameElement(), -1); 10976 for (int i = 0; i < element.getVariable().size(); i++) 10977 composeString(t, "StructureMap", "variable", element.getVariable().get(i), i); 10978 } 10979 10980 protected void composeSubscription(Complex parent, String parentType, String name, Subscription element, int index) { 10981 if (element == null) 10982 return; 10983 Complex t; 10984 if (Utilities.noString(parentType)) 10985 t = parent; 10986 else { 10987 t = parent.predicate("fhir:"+parentType+'.'+name); 10988 } 10989 composeDomainResource(t, "Subscription", name, element, index); 10990 if (element.hasCriteriaElement()) 10991 composeString(t, "Subscription", "criteria", element.getCriteriaElement(), -1); 10992 for (int i = 0; i < element.getContact().size(); i++) 10993 composeContactPoint(t, "Subscription", "contact", element.getContact().get(i), i); 10994 if (element.hasReasonElement()) 10995 composeString(t, "Subscription", "reason", element.getReasonElement(), -1); 10996 if (element.hasStatusElement()) 10997 composeEnum(t, "Subscription", "status", element.getStatusElement(), -1); 10998 if (element.hasErrorElement()) 10999 composeString(t, "Subscription", "error", element.getErrorElement(), -1); 11000 if (element.hasChannel()) 11001 composeSubscriptionSubscriptionChannelComponent(t, "Subscription", "channel", element.getChannel(), -1); 11002 if (element.hasEndElement()) 11003 composeInstant(t, "Subscription", "end", element.getEndElement(), -1); 11004 for (int i = 0; i < element.getTag().size(); i++) 11005 composeCoding(t, "Subscription", "tag", element.getTag().get(i), i); 11006 } 11007 11008 protected void composeSubscriptionSubscriptionChannelComponent(Complex parent, String parentType, String name, Subscription.SubscriptionChannelComponent element, int index) { 11009 if (element == null) 11010 return; 11011 Complex t; 11012 if (Utilities.noString(parentType)) 11013 t = parent; 11014 else { 11015 t = parent.predicate("fhir:"+parentType+'.'+name); 11016 } 11017 composeBackboneElement(t, "channel", name, element, index); 11018 if (element.hasTypeElement()) 11019 composeEnum(t, "Subscription", "type", element.getTypeElement(), -1); 11020 if (element.hasEndpointElement()) 11021 composeUri(t, "Subscription", "endpoint", element.getEndpointElement(), -1); 11022 if (element.hasPayloadElement()) 11023 composeString(t, "Subscription", "payload", element.getPayloadElement(), -1); 11024 if (element.hasHeaderElement()) 11025 composeString(t, "Subscription", "header", element.getHeaderElement(), -1); 11026 } 11027 11028 protected void composeSubstance(Complex parent, String parentType, String name, Substance element, int index) { 11029 if (element == null) 11030 return; 11031 Complex t; 11032 if (Utilities.noString(parentType)) 11033 t = parent; 11034 else { 11035 t = parent.predicate("fhir:"+parentType+'.'+name); 11036 } 11037 composeDomainResource(t, "Substance", name, element, index); 11038 for (int i = 0; i < element.getIdentifier().size(); i++) 11039 composeIdentifier(t, "Substance", "identifier", element.getIdentifier().get(i), i); 11040 for (int i = 0; i < element.getCategory().size(); i++) 11041 composeCodeableConcept(t, "Substance", "category", element.getCategory().get(i), i); 11042 if (element.hasCode()) 11043 composeCodeableConcept(t, "Substance", "code", element.getCode(), -1); 11044 if (element.hasDescriptionElement()) 11045 composeString(t, "Substance", "description", element.getDescriptionElement(), -1); 11046 for (int i = 0; i < element.getInstance().size(); i++) 11047 composeSubstanceSubstanceInstanceComponent(t, "Substance", "instance", element.getInstance().get(i), i); 11048 for (int i = 0; i < element.getIngredient().size(); i++) 11049 composeSubstanceSubstanceIngredientComponent(t, "Substance", "ingredient", element.getIngredient().get(i), i); 11050 } 11051 11052 protected void composeSubstanceSubstanceInstanceComponent(Complex parent, String parentType, String name, Substance.SubstanceInstanceComponent element, int index) { 11053 if (element == null) 11054 return; 11055 Complex t; 11056 if (Utilities.noString(parentType)) 11057 t = parent; 11058 else { 11059 t = parent.predicate("fhir:"+parentType+'.'+name); 11060 } 11061 composeBackboneElement(t, "instance", name, element, index); 11062 if (element.hasIdentifier()) 11063 composeIdentifier(t, "Substance", "identifier", element.getIdentifier(), -1); 11064 if (element.hasExpiryElement()) 11065 composeDateTime(t, "Substance", "expiry", element.getExpiryElement(), -1); 11066 if (element.hasQuantity()) 11067 composeQuantity(t, "Substance", "quantity", element.getQuantity(), -1); 11068 } 11069 11070 protected void composeSubstanceSubstanceIngredientComponent(Complex parent, String parentType, String name, Substance.SubstanceIngredientComponent element, int index) { 11071 if (element == null) 11072 return; 11073 Complex t; 11074 if (Utilities.noString(parentType)) 11075 t = parent; 11076 else { 11077 t = parent.predicate("fhir:"+parentType+'.'+name); 11078 } 11079 composeBackboneElement(t, "ingredient", name, element, index); 11080 if (element.hasQuantity()) 11081 composeRatio(t, "Substance", "quantity", element.getQuantity(), -1); 11082 if (element.hasSubstance()) 11083 composeReference(t, "Substance", "substance", element.getSubstance(), -1); 11084 } 11085 11086 protected void composeSupplyDelivery(Complex parent, String parentType, String name, SupplyDelivery element, int index) { 11087 if (element == null) 11088 return; 11089 Complex t; 11090 if (Utilities.noString(parentType)) 11091 t = parent; 11092 else { 11093 t = parent.predicate("fhir:"+parentType+'.'+name); 11094 } 11095 composeDomainResource(t, "SupplyDelivery", name, element, index); 11096 if (element.hasIdentifier()) 11097 composeIdentifier(t, "SupplyDelivery", "identifier", element.getIdentifier(), -1); 11098 if (element.hasStatusElement()) 11099 composeEnum(t, "SupplyDelivery", "status", element.getStatusElement(), -1); 11100 if (element.hasPatient()) 11101 composeReference(t, "SupplyDelivery", "patient", element.getPatient(), -1); 11102 if (element.hasType()) 11103 composeCodeableConcept(t, "SupplyDelivery", "type", element.getType(), -1); 11104 if (element.hasQuantity()) 11105 composeQuantity(t, "SupplyDelivery", "quantity", element.getQuantity(), -1); 11106 if (element.hasSuppliedItem()) 11107 composeReference(t, "SupplyDelivery", "suppliedItem", element.getSuppliedItem(), -1); 11108 if (element.hasSupplier()) 11109 composeReference(t, "SupplyDelivery", "supplier", element.getSupplier(), -1); 11110 if (element.hasWhenPrepared()) 11111 composePeriod(t, "SupplyDelivery", "whenPrepared", element.getWhenPrepared(), -1); 11112 if (element.hasTimeElement()) 11113 composeDateTime(t, "SupplyDelivery", "time", element.getTimeElement(), -1); 11114 if (element.hasDestination()) 11115 composeReference(t, "SupplyDelivery", "destination", element.getDestination(), -1); 11116 for (int i = 0; i < element.getReceiver().size(); i++) 11117 composeReference(t, "SupplyDelivery", "receiver", element.getReceiver().get(i), i); 11118 } 11119 11120 protected void composeSupplyRequest(Complex parent, String parentType, String name, SupplyRequest element, int index) { 11121 if (element == null) 11122 return; 11123 Complex t; 11124 if (Utilities.noString(parentType)) 11125 t = parent; 11126 else { 11127 t = parent.predicate("fhir:"+parentType+'.'+name); 11128 } 11129 composeDomainResource(t, "SupplyRequest", name, element, index); 11130 if (element.hasPatient()) 11131 composeReference(t, "SupplyRequest", "patient", element.getPatient(), -1); 11132 if (element.hasSource()) 11133 composeReference(t, "SupplyRequest", "source", element.getSource(), -1); 11134 if (element.hasDateElement()) 11135 composeDateTime(t, "SupplyRequest", "date", element.getDateElement(), -1); 11136 if (element.hasIdentifier()) 11137 composeIdentifier(t, "SupplyRequest", "identifier", element.getIdentifier(), -1); 11138 if (element.hasStatusElement()) 11139 composeEnum(t, "SupplyRequest", "status", element.getStatusElement(), -1); 11140 if (element.hasKind()) 11141 composeCodeableConcept(t, "SupplyRequest", "kind", element.getKind(), -1); 11142 if (element.hasOrderedItem()) 11143 composeReference(t, "SupplyRequest", "orderedItem", element.getOrderedItem(), -1); 11144 for (int i = 0; i < element.getSupplier().size(); i++) 11145 composeReference(t, "SupplyRequest", "supplier", element.getSupplier().get(i), i); 11146 if (element.hasReason()) 11147 composeType(t, "SupplyRequest", "reason", element.getReason(), -1); 11148 if (element.hasWhen()) 11149 composeSupplyRequestSupplyRequestWhenComponent(t, "SupplyRequest", "when", element.getWhen(), -1); 11150 } 11151 11152 protected void composeSupplyRequestSupplyRequestWhenComponent(Complex parent, String parentType, String name, SupplyRequest.SupplyRequestWhenComponent element, int index) { 11153 if (element == null) 11154 return; 11155 Complex t; 11156 if (Utilities.noString(parentType)) 11157 t = parent; 11158 else { 11159 t = parent.predicate("fhir:"+parentType+'.'+name); 11160 } 11161 composeBackboneElement(t, "when", name, element, index); 11162 if (element.hasCode()) 11163 composeCodeableConcept(t, "SupplyRequest", "code", element.getCode(), -1); 11164 if (element.hasSchedule()) 11165 composeTiming(t, "SupplyRequest", "schedule", element.getSchedule(), -1); 11166 } 11167 11168 protected void composeTask(Complex parent, String parentType, String name, Task element, int index) { 11169 if (element == null) 11170 return; 11171 Complex t; 11172 if (Utilities.noString(parentType)) 11173 t = parent; 11174 else { 11175 t = parent.predicate("fhir:"+parentType+'.'+name); 11176 } 11177 composeDomainResource(t, "Task", name, element, index); 11178 if (element.hasIdentifier()) 11179 composeIdentifier(t, "Task", "identifier", element.getIdentifier(), -1); 11180 if (element.hasType()) 11181 composeCodeableConcept(t, "Task", "type", element.getType(), -1); 11182 if (element.hasDescriptionElement()) 11183 composeString(t, "Task", "description", element.getDescriptionElement(), -1); 11184 for (int i = 0; i < element.getPerformerType().size(); i++) 11185 composeCoding(t, "Task", "performerType", element.getPerformerType().get(i), i); 11186 if (element.hasPriorityElement()) 11187 composeEnum(t, "Task", "priority", element.getPriorityElement(), -1); 11188 if (element.hasStatusElement()) 11189 composeEnum(t, "Task", "status", element.getStatusElement(), -1); 11190 if (element.hasFailureReason()) 11191 composeCodeableConcept(t, "Task", "failureReason", element.getFailureReason(), -1); 11192 if (element.hasSubject()) 11193 composeReference(t, "Task", "subject", element.getSubject(), -1); 11194 if (element.hasFor()) 11195 composeReference(t, "Task", "for", element.getFor(), -1); 11196 if (element.hasDefinitionElement()) 11197 composeUri(t, "Task", "definition", element.getDefinitionElement(), -1); 11198 if (element.hasCreatedElement()) 11199 composeDateTime(t, "Task", "created", element.getCreatedElement(), -1); 11200 if (element.hasLastModifiedElement()) 11201 composeDateTime(t, "Task", "lastModified", element.getLastModifiedElement(), -1); 11202 if (element.hasCreator()) 11203 composeReference(t, "Task", "creator", element.getCreator(), -1); 11204 if (element.hasOwner()) 11205 composeReference(t, "Task", "owner", element.getOwner(), -1); 11206 if (element.hasParent()) 11207 composeReference(t, "Task", "parent", element.getParent(), -1); 11208 for (int i = 0; i < element.getInput().size(); i++) 11209 composeTaskParameterComponent(t, "Task", "input", element.getInput().get(i), i); 11210 for (int i = 0; i < element.getOutput().size(); i++) 11211 composeTaskTaskOutputComponent(t, "Task", "output", element.getOutput().get(i), i); 11212 } 11213 11214 protected void composeTaskParameterComponent(Complex parent, String parentType, String name, Task.ParameterComponent element, int index) { 11215 if (element == null) 11216 return; 11217 Complex t; 11218 if (Utilities.noString(parentType)) 11219 t = parent; 11220 else { 11221 t = parent.predicate("fhir:"+parentType+'.'+name); 11222 } 11223 composeBackboneElement(t, "input", name, element, index); 11224 if (element.hasNameElement()) 11225 composeString(t, "Task", "name", element.getNameElement(), -1); 11226 if (element.hasValue()) 11227 composeType(t, "Task", "value", element.getValue(), -1); 11228 } 11229 11230 protected void composeTaskTaskOutputComponent(Complex parent, String parentType, String name, Task.TaskOutputComponent element, int index) { 11231 if (element == null) 11232 return; 11233 Complex t; 11234 if (Utilities.noString(parentType)) 11235 t = parent; 11236 else { 11237 t = parent.predicate("fhir:"+parentType+'.'+name); 11238 } 11239 composeBackboneElement(t, "output", name, element, index); 11240 if (element.hasNameElement()) 11241 composeString(t, "Task", "name", element.getNameElement(), -1); 11242 if (element.hasValue()) 11243 composeType(t, "Task", "value", element.getValue(), -1); 11244 } 11245 11246 protected void composeTestScript(Complex parent, String parentType, String name, TestScript element, int index) { 11247 if (element == null) 11248 return; 11249 Complex t; 11250 if (Utilities.noString(parentType)) 11251 t = parent; 11252 else { 11253 t = parent.predicate("fhir:"+parentType+'.'+name); 11254 } 11255 composeDomainResource(t, "TestScript", name, element, index); 11256 if (element.hasUrlElement()) 11257 composeUri(t, "TestScript", "url", element.getUrlElement(), -1); 11258 if (element.hasVersionElement()) 11259 composeString(t, "TestScript", "version", element.getVersionElement(), -1); 11260 if (element.hasNameElement()) 11261 composeString(t, "TestScript", "name", element.getNameElement(), -1); 11262 if (element.hasStatusElement()) 11263 composeEnum(t, "TestScript", "status", element.getStatusElement(), -1); 11264 if (element.hasIdentifier()) 11265 composeIdentifier(t, "TestScript", "identifier", element.getIdentifier(), -1); 11266 if (element.hasExperimentalElement()) 11267 composeBoolean(t, "TestScript", "experimental", element.getExperimentalElement(), -1); 11268 if (element.hasPublisherElement()) 11269 composeString(t, "TestScript", "publisher", element.getPublisherElement(), -1); 11270 for (int i = 0; i < element.getContact().size(); i++) 11271 composeTestScriptTestScriptContactComponent(t, "TestScript", "contact", element.getContact().get(i), i); 11272 if (element.hasDateElement()) 11273 composeDateTime(t, "TestScript", "date", element.getDateElement(), -1); 11274 if (element.hasDescriptionElement()) 11275 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 11276 for (int i = 0; i < element.getUseContext().size(); i++) 11277 composeCodeableConcept(t, "TestScript", "useContext", element.getUseContext().get(i), i); 11278 if (element.hasRequirementsElement()) 11279 composeString(t, "TestScript", "requirements", element.getRequirementsElement(), -1); 11280 if (element.hasCopyrightElement()) 11281 composeString(t, "TestScript", "copyright", element.getCopyrightElement(), -1); 11282 for (int i = 0; i < element.getOrigin().size(); i++) 11283 composeTestScriptTestScriptOriginComponent(t, "TestScript", "origin", element.getOrigin().get(i), i); 11284 for (int i = 0; i < element.getDestination().size(); i++) 11285 composeTestScriptTestScriptDestinationComponent(t, "TestScript", "destination", element.getDestination().get(i), i); 11286 if (element.hasMetadata()) 11287 composeTestScriptTestScriptMetadataComponent(t, "TestScript", "metadata", element.getMetadata(), -1); 11288 for (int i = 0; i < element.getFixture().size(); i++) 11289 composeTestScriptTestScriptFixtureComponent(t, "TestScript", "fixture", element.getFixture().get(i), i); 11290 for (int i = 0; i < element.getProfile().size(); i++) 11291 composeReference(t, "TestScript", "profile", element.getProfile().get(i), i); 11292 for (int i = 0; i < element.getVariable().size(); i++) 11293 composeTestScriptTestScriptVariableComponent(t, "TestScript", "variable", element.getVariable().get(i), i); 11294 for (int i = 0; i < element.getRule().size(); i++) 11295 composeTestScriptTestScriptRuleComponent(t, "TestScript", "rule", element.getRule().get(i), i); 11296 for (int i = 0; i < element.getRuleset().size(); i++) 11297 composeTestScriptTestScriptRulesetComponent(t, "TestScript", "ruleset", element.getRuleset().get(i), i); 11298 if (element.hasSetup()) 11299 composeTestScriptTestScriptSetupComponent(t, "TestScript", "setup", element.getSetup(), -1); 11300 for (int i = 0; i < element.getTest().size(); i++) 11301 composeTestScriptTestScriptTestComponent(t, "TestScript", "test", element.getTest().get(i), i); 11302 if (element.hasTeardown()) 11303 composeTestScriptTestScriptTeardownComponent(t, "TestScript", "teardown", element.getTeardown(), -1); 11304 } 11305 11306 protected void composeTestScriptTestScriptContactComponent(Complex parent, String parentType, String name, TestScript.TestScriptContactComponent element, int index) { 11307 if (element == null) 11308 return; 11309 Complex t; 11310 if (Utilities.noString(parentType)) 11311 t = parent; 11312 else { 11313 t = parent.predicate("fhir:"+parentType+'.'+name); 11314 } 11315 composeBackboneElement(t, "contact", name, element, index); 11316 if (element.hasNameElement()) 11317 composeString(t, "TestScript", "name", element.getNameElement(), -1); 11318 for (int i = 0; i < element.getTelecom().size(); i++) 11319 composeContactPoint(t, "TestScript", "telecom", element.getTelecom().get(i), i); 11320 } 11321 11322 protected void composeTestScriptTestScriptOriginComponent(Complex parent, String parentType, String name, TestScript.TestScriptOriginComponent element, int index) { 11323 if (element == null) 11324 return; 11325 Complex t; 11326 if (Utilities.noString(parentType)) 11327 t = parent; 11328 else { 11329 t = parent.predicate("fhir:"+parentType+'.'+name); 11330 } 11331 composeBackboneElement(t, "origin", name, element, index); 11332 if (element.hasIndexElement()) 11333 composeInteger(t, "TestScript", "index", element.getIndexElement(), -1); 11334 if (element.hasProfile()) 11335 composeCoding(t, "TestScript", "profile", element.getProfile(), -1); 11336 } 11337 11338 protected void composeTestScriptTestScriptDestinationComponent(Complex parent, String parentType, String name, TestScript.TestScriptDestinationComponent element, int index) { 11339 if (element == null) 11340 return; 11341 Complex t; 11342 if (Utilities.noString(parentType)) 11343 t = parent; 11344 else { 11345 t = parent.predicate("fhir:"+parentType+'.'+name); 11346 } 11347 composeBackboneElement(t, "destination", name, element, index); 11348 if (element.hasIndexElement()) 11349 composeInteger(t, "TestScript", "index", element.getIndexElement(), -1); 11350 if (element.hasProfile()) 11351 composeCoding(t, "TestScript", "profile", element.getProfile(), -1); 11352 } 11353 11354 protected void composeTestScriptTestScriptMetadataComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataComponent element, int index) { 11355 if (element == null) 11356 return; 11357 Complex t; 11358 if (Utilities.noString(parentType)) 11359 t = parent; 11360 else { 11361 t = parent.predicate("fhir:"+parentType+'.'+name); 11362 } 11363 composeBackboneElement(t, "metadata", name, element, index); 11364 for (int i = 0; i < element.getLink().size(); i++) 11365 composeTestScriptTestScriptMetadataLinkComponent(t, "TestScript", "link", element.getLink().get(i), i); 11366 for (int i = 0; i < element.getCapability().size(); i++) 11367 composeTestScriptTestScriptMetadataCapabilityComponent(t, "TestScript", "capability", element.getCapability().get(i), i); 11368 } 11369 11370 protected void composeTestScriptTestScriptMetadataLinkComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataLinkComponent element, int index) { 11371 if (element == null) 11372 return; 11373 Complex t; 11374 if (Utilities.noString(parentType)) 11375 t = parent; 11376 else { 11377 t = parent.predicate("fhir:"+parentType+'.'+name); 11378 } 11379 composeBackboneElement(t, "link", name, element, index); 11380 if (element.hasUrlElement()) 11381 composeUri(t, "TestScript", "url", element.getUrlElement(), -1); 11382 if (element.hasDescriptionElement()) 11383 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 11384 } 11385 11386 protected void composeTestScriptTestScriptMetadataCapabilityComponent(Complex parent, String parentType, String name, TestScript.TestScriptMetadataCapabilityComponent element, int index) { 11387 if (element == null) 11388 return; 11389 Complex t; 11390 if (Utilities.noString(parentType)) 11391 t = parent; 11392 else { 11393 t = parent.predicate("fhir:"+parentType+'.'+name); 11394 } 11395 composeBackboneElement(t, "capability", name, element, index); 11396 if (element.hasRequiredElement()) 11397 composeBoolean(t, "TestScript", "required", element.getRequiredElement(), -1); 11398 if (element.hasValidatedElement()) 11399 composeBoolean(t, "TestScript", "validated", element.getValidatedElement(), -1); 11400 if (element.hasDescriptionElement()) 11401 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 11402 for (int i = 0; i < element.getOrigin().size(); i++) 11403 composeInteger(t, "TestScript", "origin", element.getOrigin().get(i), i); 11404 if (element.hasDestinationElement()) 11405 composeInteger(t, "TestScript", "destination", element.getDestinationElement(), -1); 11406 for (int i = 0; i < element.getLink().size(); i++) 11407 composeUri(t, "TestScript", "link", element.getLink().get(i), i); 11408 if (element.hasConformance()) 11409 composeReference(t, "TestScript", "conformance", element.getConformance(), -1); 11410 } 11411 11412 protected void composeTestScriptTestScriptFixtureComponent(Complex parent, String parentType, String name, TestScript.TestScriptFixtureComponent element, int index) { 11413 if (element == null) 11414 return; 11415 Complex t; 11416 if (Utilities.noString(parentType)) 11417 t = parent; 11418 else { 11419 t = parent.predicate("fhir:"+parentType+'.'+name); 11420 } 11421 composeBackboneElement(t, "fixture", name, element, index); 11422 if (element.hasAutocreateElement()) 11423 composeBoolean(t, "TestScript", "autocreate", element.getAutocreateElement(), -1); 11424 if (element.hasAutodeleteElement()) 11425 composeBoolean(t, "TestScript", "autodelete", element.getAutodeleteElement(), -1); 11426 if (element.hasResource()) 11427 composeReference(t, "TestScript", "resource", element.getResource(), -1); 11428 } 11429 11430 protected void composeTestScriptTestScriptVariableComponent(Complex parent, String parentType, String name, TestScript.TestScriptVariableComponent element, int index) { 11431 if (element == null) 11432 return; 11433 Complex t; 11434 if (Utilities.noString(parentType)) 11435 t = parent; 11436 else { 11437 t = parent.predicate("fhir:"+parentType+'.'+name); 11438 } 11439 composeBackboneElement(t, "variable", name, element, index); 11440 if (element.hasNameElement()) 11441 composeString(t, "TestScript", "name", element.getNameElement(), -1); 11442 if (element.hasDefaultValueElement()) 11443 composeString(t, "TestScript", "defaultValue", element.getDefaultValueElement(), -1); 11444 if (element.hasHeaderFieldElement()) 11445 composeString(t, "TestScript", "headerField", element.getHeaderFieldElement(), -1); 11446 if (element.hasPathElement()) 11447 composeString(t, "TestScript", "path", element.getPathElement(), -1); 11448 if (element.hasSourceIdElement()) 11449 composeId(t, "TestScript", "sourceId", element.getSourceIdElement(), -1); 11450 } 11451 11452 protected void composeTestScriptTestScriptRuleComponent(Complex parent, String parentType, String name, TestScript.TestScriptRuleComponent element, int index) { 11453 if (element == null) 11454 return; 11455 Complex t; 11456 if (Utilities.noString(parentType)) 11457 t = parent; 11458 else { 11459 t = parent.predicate("fhir:"+parentType+'.'+name); 11460 } 11461 composeBackboneElement(t, "rule", name, element, index); 11462 if (element.hasResource()) 11463 composeReference(t, "TestScript", "resource", element.getResource(), -1); 11464 for (int i = 0; i < element.getParam().size(); i++) 11465 composeTestScriptTestScriptRuleParamComponent(t, "TestScript", "param", element.getParam().get(i), i); 11466 } 11467 11468 protected void composeTestScriptTestScriptRuleParamComponent(Complex parent, String parentType, String name, TestScript.TestScriptRuleParamComponent element, int index) { 11469 if (element == null) 11470 return; 11471 Complex t; 11472 if (Utilities.noString(parentType)) 11473 t = parent; 11474 else { 11475 t = parent.predicate("fhir:"+parentType+'.'+name); 11476 } 11477 composeBackboneElement(t, "param", name, element, index); 11478 if (element.hasNameElement()) 11479 composeString(t, "TestScript", "name", element.getNameElement(), -1); 11480 if (element.hasValueElement()) 11481 composeString(t, "TestScript", "value", element.getValueElement(), -1); 11482 } 11483 11484 protected void composeTestScriptTestScriptRulesetComponent(Complex parent, String parentType, String name, TestScript.TestScriptRulesetComponent element, int index) { 11485 if (element == null) 11486 return; 11487 Complex t; 11488 if (Utilities.noString(parentType)) 11489 t = parent; 11490 else { 11491 t = parent.predicate("fhir:"+parentType+'.'+name); 11492 } 11493 composeBackboneElement(t, "ruleset", name, element, index); 11494 if (element.hasResource()) 11495 composeReference(t, "TestScript", "resource", element.getResource(), -1); 11496 for (int i = 0; i < element.getRule().size(); i++) 11497 composeTestScriptTestScriptRulesetRuleComponent(t, "TestScript", "rule", element.getRule().get(i), i); 11498 } 11499 11500 protected void composeTestScriptTestScriptRulesetRuleComponent(Complex parent, String parentType, String name, TestScript.TestScriptRulesetRuleComponent element, int index) { 11501 if (element == null) 11502 return; 11503 Complex t; 11504 if (Utilities.noString(parentType)) 11505 t = parent; 11506 else { 11507 t = parent.predicate("fhir:"+parentType+'.'+name); 11508 } 11509 composeBackboneElement(t, "rule", name, element, index); 11510 if (element.hasRuleIdElement()) 11511 composeId(t, "TestScript", "ruleId", element.getRuleIdElement(), -1); 11512 for (int i = 0; i < element.getParam().size(); i++) 11513 composeTestScriptTestScriptRulesetRuleParamComponent(t, "TestScript", "param", element.getParam().get(i), i); 11514 } 11515 11516 protected void composeTestScriptTestScriptRulesetRuleParamComponent(Complex parent, String parentType, String name, TestScript.TestScriptRulesetRuleParamComponent element, int index) { 11517 if (element == null) 11518 return; 11519 Complex t; 11520 if (Utilities.noString(parentType)) 11521 t = parent; 11522 else { 11523 t = parent.predicate("fhir:"+parentType+'.'+name); 11524 } 11525 composeBackboneElement(t, "param", name, element, index); 11526 if (element.hasNameElement()) 11527 composeString(t, "TestScript", "name", element.getNameElement(), -1); 11528 if (element.hasValueElement()) 11529 composeString(t, "TestScript", "value", element.getValueElement(), -1); 11530 } 11531 11532 protected void composeTestScriptTestScriptSetupComponent(Complex parent, String parentType, String name, TestScript.TestScriptSetupComponent element, int index) { 11533 if (element == null) 11534 return; 11535 Complex t; 11536 if (Utilities.noString(parentType)) 11537 t = parent; 11538 else { 11539 t = parent.predicate("fhir:"+parentType+'.'+name); 11540 } 11541 composeBackboneElement(t, "setup", name, element, index); 11542 if (element.hasMetadata()) 11543 composeTestScriptTestScriptMetadataComponent(t, "TestScript", "metadata", element.getMetadata(), -1); 11544 for (int i = 0; i < element.getAction().size(); i++) 11545 composeTestScriptSetupActionComponent(t, "TestScript", "action", element.getAction().get(i), i); 11546 } 11547 11548 protected void composeTestScriptSetupActionComponent(Complex parent, String parentType, String name, TestScript.SetupActionComponent element, int index) { 11549 if (element == null) 11550 return; 11551 Complex t; 11552 if (Utilities.noString(parentType)) 11553 t = parent; 11554 else { 11555 t = parent.predicate("fhir:"+parentType+'.'+name); 11556 } 11557 composeBackboneElement(t, "action", name, element, index); 11558 if (element.hasOperation()) 11559 composeTestScriptSetupActionOperationComponent(t, "TestScript", "operation", element.getOperation(), -1); 11560 if (element.hasAssert()) 11561 composeTestScriptSetupActionAssertComponent(t, "TestScript", "assert", element.getAssert(), -1); 11562 } 11563 11564 protected void composeTestScriptSetupActionOperationComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationComponent element, int index) { 11565 if (element == null) 11566 return; 11567 Complex t; 11568 if (Utilities.noString(parentType)) 11569 t = parent; 11570 else { 11571 t = parent.predicate("fhir:"+parentType+'.'+name); 11572 } 11573 composeBackboneElement(t, "operation", name, element, index); 11574 if (element.hasType()) 11575 composeCoding(t, "TestScript", "type", element.getType(), -1); 11576 if (element.hasResourceElement()) 11577 composeCode(t, "TestScript", "resource", element.getResourceElement(), -1); 11578 if (element.hasLabelElement()) 11579 composeString(t, "TestScript", "label", element.getLabelElement(), -1); 11580 if (element.hasDescriptionElement()) 11581 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 11582 if (element.hasAcceptElement()) 11583 composeEnum(t, "TestScript", "accept", element.getAcceptElement(), -1); 11584 if (element.hasContentTypeElement()) 11585 composeEnum(t, "TestScript", "contentType", element.getContentTypeElement(), -1); 11586 if (element.hasDestinationElement()) 11587 composeInteger(t, "TestScript", "destination", element.getDestinationElement(), -1); 11588 if (element.hasEncodeRequestUrlElement()) 11589 composeBoolean(t, "TestScript", "encodeRequestUrl", element.getEncodeRequestUrlElement(), -1); 11590 if (element.hasOriginElement()) 11591 composeInteger(t, "TestScript", "origin", element.getOriginElement(), -1); 11592 if (element.hasParamsElement()) 11593 composeString(t, "TestScript", "params", element.getParamsElement(), -1); 11594 for (int i = 0; i < element.getRequestHeader().size(); i++) 11595 composeTestScriptSetupActionOperationRequestHeaderComponent(t, "TestScript", "requestHeader", element.getRequestHeader().get(i), i); 11596 if (element.hasResponseIdElement()) 11597 composeId(t, "TestScript", "responseId", element.getResponseIdElement(), -1); 11598 if (element.hasSourceIdElement()) 11599 composeId(t, "TestScript", "sourceId", element.getSourceIdElement(), -1); 11600 if (element.hasTargetIdElement()) 11601 composeId(t, "TestScript", "targetId", element.getTargetIdElement(), -1); 11602 if (element.hasUrlElement()) 11603 composeString(t, "TestScript", "url", element.getUrlElement(), -1); 11604 } 11605 11606 protected void composeTestScriptSetupActionOperationRequestHeaderComponent(Complex parent, String parentType, String name, TestScript.SetupActionOperationRequestHeaderComponent element, int index) { 11607 if (element == null) 11608 return; 11609 Complex t; 11610 if (Utilities.noString(parentType)) 11611 t = parent; 11612 else { 11613 t = parent.predicate("fhir:"+parentType+'.'+name); 11614 } 11615 composeBackboneElement(t, "requestHeader", name, element, index); 11616 if (element.hasFieldElement()) 11617 composeString(t, "TestScript", "field", element.getFieldElement(), -1); 11618 if (element.hasValueElement()) 11619 composeString(t, "TestScript", "value", element.getValueElement(), -1); 11620 } 11621 11622 protected void composeTestScriptSetupActionAssertComponent(Complex parent, String parentType, String name, TestScript.SetupActionAssertComponent element, int index) { 11623 if (element == null) 11624 return; 11625 Complex t; 11626 if (Utilities.noString(parentType)) 11627 t = parent; 11628 else { 11629 t = parent.predicate("fhir:"+parentType+'.'+name); 11630 } 11631 composeBackboneElement(t, "assert", name, element, index); 11632 if (element.hasLabelElement()) 11633 composeString(t, "TestScript", "label", element.getLabelElement(), -1); 11634 if (element.hasDescriptionElement()) 11635 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 11636 if (element.hasDirectionElement()) 11637 composeEnum(t, "TestScript", "direction", element.getDirectionElement(), -1); 11638 if (element.hasCompareToSourceIdElement()) 11639 composeString(t, "TestScript", "compareToSourceId", element.getCompareToSourceIdElement(), -1); 11640 if (element.hasCompareToSourcePathElement()) 11641 composeString(t, "TestScript", "compareToSourcePath", element.getCompareToSourcePathElement(), -1); 11642 if (element.hasContentTypeElement()) 11643 composeEnum(t, "TestScript", "contentType", element.getContentTypeElement(), -1); 11644 if (element.hasHeaderFieldElement()) 11645 composeString(t, "TestScript", "headerField", element.getHeaderFieldElement(), -1); 11646 if (element.hasMinimumIdElement()) 11647 composeString(t, "TestScript", "minimumId", element.getMinimumIdElement(), -1); 11648 if (element.hasNavigationLinksElement()) 11649 composeBoolean(t, "TestScript", "navigationLinks", element.getNavigationLinksElement(), -1); 11650 if (element.hasOperatorElement()) 11651 composeEnum(t, "TestScript", "operator", element.getOperatorElement(), -1); 11652 if (element.hasPathElement()) 11653 composeString(t, "TestScript", "path", element.getPathElement(), -1); 11654 if (element.hasResourceElement()) 11655 composeCode(t, "TestScript", "resource", element.getResourceElement(), -1); 11656 if (element.hasResponseElement()) 11657 composeEnum(t, "TestScript", "response", element.getResponseElement(), -1); 11658 if (element.hasResponseCodeElement()) 11659 composeString(t, "TestScript", "responseCode", element.getResponseCodeElement(), -1); 11660 if (element.hasRule()) 11661 composeTestScriptSetupActionAssertRuleComponent(t, "TestScript", "rule", element.getRule(), -1); 11662 if (element.hasRuleset()) 11663 composeTestScriptSetupActionAssertRulesetComponent(t, "TestScript", "ruleset", element.getRuleset(), -1); 11664 if (element.hasSourceIdElement()) 11665 composeId(t, "TestScript", "sourceId", element.getSourceIdElement(), -1); 11666 if (element.hasValidateProfileIdElement()) 11667 composeId(t, "TestScript", "validateProfileId", element.getValidateProfileIdElement(), -1); 11668 if (element.hasValueElement()) 11669 composeString(t, "TestScript", "value", element.getValueElement(), -1); 11670 if (element.hasWarningOnlyElement()) 11671 composeBoolean(t, "TestScript", "warningOnly", element.getWarningOnlyElement(), -1); 11672 } 11673 11674 protected void composeTestScriptSetupActionAssertRuleComponent(Complex parent, String parentType, String name, TestScript.SetupActionAssertRuleComponent element, int index) { 11675 if (element == null) 11676 return; 11677 Complex t; 11678 if (Utilities.noString(parentType)) 11679 t = parent; 11680 else { 11681 t = parent.predicate("fhir:"+parentType+'.'+name); 11682 } 11683 composeBackboneElement(t, "rule", name, element, index); 11684 if (element.hasRuleIdElement()) 11685 composeId(t, "TestScript", "ruleId", element.getRuleIdElement(), -1); 11686 for (int i = 0; i < element.getParam().size(); i++) 11687 composeTestScriptSetupActionAssertRuleParamComponent(t, "TestScript", "param", element.getParam().get(i), i); 11688 } 11689 11690 protected void composeTestScriptSetupActionAssertRuleParamComponent(Complex parent, String parentType, String name, TestScript.SetupActionAssertRuleParamComponent element, int index) { 11691 if (element == null) 11692 return; 11693 Complex t; 11694 if (Utilities.noString(parentType)) 11695 t = parent; 11696 else { 11697 t = parent.predicate("fhir:"+parentType+'.'+name); 11698 } 11699 composeBackboneElement(t, "param", name, element, index); 11700 if (element.hasNameElement()) 11701 composeString(t, "TestScript", "name", element.getNameElement(), -1); 11702 if (element.hasValueElement()) 11703 composeString(t, "TestScript", "value", element.getValueElement(), -1); 11704 } 11705 11706 protected void composeTestScriptSetupActionAssertRulesetComponent(Complex parent, String parentType, String name, TestScript.SetupActionAssertRulesetComponent element, int index) { 11707 if (element == null) 11708 return; 11709 Complex t; 11710 if (Utilities.noString(parentType)) 11711 t = parent; 11712 else { 11713 t = parent.predicate("fhir:"+parentType+'.'+name); 11714 } 11715 composeBackboneElement(t, "ruleset", name, element, index); 11716 if (element.hasRulesetIdElement()) 11717 composeId(t, "TestScript", "rulesetId", element.getRulesetIdElement(), -1); 11718 for (int i = 0; i < element.getRule().size(); i++) 11719 composeTestScriptSetupActionAssertRulesetRuleComponent(t, "TestScript", "rule", element.getRule().get(i), i); 11720 } 11721 11722 protected void composeTestScriptSetupActionAssertRulesetRuleComponent(Complex parent, String parentType, String name, TestScript.SetupActionAssertRulesetRuleComponent element, int index) { 11723 if (element == null) 11724 return; 11725 Complex t; 11726 if (Utilities.noString(parentType)) 11727 t = parent; 11728 else { 11729 t = parent.predicate("fhir:"+parentType+'.'+name); 11730 } 11731 composeBackboneElement(t, "rule", name, element, index); 11732 if (element.hasRuleIdElement()) 11733 composeId(t, "TestScript", "ruleId", element.getRuleIdElement(), -1); 11734 for (int i = 0; i < element.getParam().size(); i++) 11735 composeTestScriptSetupActionAssertRulesetRuleParamComponent(t, "TestScript", "param", element.getParam().get(i), i); 11736 } 11737 11738 protected void composeTestScriptSetupActionAssertRulesetRuleParamComponent(Complex parent, String parentType, String name, TestScript.SetupActionAssertRulesetRuleParamComponent element, int index) { 11739 if (element == null) 11740 return; 11741 Complex t; 11742 if (Utilities.noString(parentType)) 11743 t = parent; 11744 else { 11745 t = parent.predicate("fhir:"+parentType+'.'+name); 11746 } 11747 composeBackboneElement(t, "param", name, element, index); 11748 if (element.hasNameElement()) 11749 composeString(t, "TestScript", "name", element.getNameElement(), -1); 11750 if (element.hasValueElement()) 11751 composeString(t, "TestScript", "value", element.getValueElement(), -1); 11752 } 11753 11754 protected void composeTestScriptTestScriptTestComponent(Complex parent, String parentType, String name, TestScript.TestScriptTestComponent element, int index) { 11755 if (element == null) 11756 return; 11757 Complex t; 11758 if (Utilities.noString(parentType)) 11759 t = parent; 11760 else { 11761 t = parent.predicate("fhir:"+parentType+'.'+name); 11762 } 11763 composeBackboneElement(t, "test", name, element, index); 11764 if (element.hasNameElement()) 11765 composeString(t, "TestScript", "name", element.getNameElement(), -1); 11766 if (element.hasDescriptionElement()) 11767 composeString(t, "TestScript", "description", element.getDescriptionElement(), -1); 11768 if (element.hasMetadata()) 11769 composeTestScriptTestScriptMetadataComponent(t, "TestScript", "metadata", element.getMetadata(), -1); 11770 for (int i = 0; i < element.getAction().size(); i++) 11771 composeTestScriptTestActionComponent(t, "TestScript", "action", element.getAction().get(i), i); 11772 } 11773 11774 protected void composeTestScriptTestActionComponent(Complex parent, String parentType, String name, TestScript.TestActionComponent element, int index) { 11775 if (element == null) 11776 return; 11777 Complex t; 11778 if (Utilities.noString(parentType)) 11779 t = parent; 11780 else { 11781 t = parent.predicate("fhir:"+parentType+'.'+name); 11782 } 11783 composeBackboneElement(t, "action", name, element, index); 11784 if (element.hasOperation()) 11785 composeTestScriptSetupActionOperationComponent(t, "TestScript", "operation", element.getOperation(), -1); 11786 if (element.hasAssert()) 11787 composeTestScriptSetupActionAssertComponent(t, "TestScript", "assert", element.getAssert(), -1); 11788 } 11789 11790 protected void composeTestScriptTestScriptTeardownComponent(Complex parent, String parentType, String name, TestScript.TestScriptTeardownComponent element, int index) { 11791 if (element == null) 11792 return; 11793 Complex t; 11794 if (Utilities.noString(parentType)) 11795 t = parent; 11796 else { 11797 t = parent.predicate("fhir:"+parentType+'.'+name); 11798 } 11799 composeBackboneElement(t, "teardown", name, element, index); 11800 for (int i = 0; i < element.getAction().size(); i++) 11801 composeTestScriptTeardownActionComponent(t, "TestScript", "action", element.getAction().get(i), i); 11802 } 11803 11804 protected void composeTestScriptTeardownActionComponent(Complex parent, String parentType, String name, TestScript.TeardownActionComponent element, int index) { 11805 if (element == null) 11806 return; 11807 Complex t; 11808 if (Utilities.noString(parentType)) 11809 t = parent; 11810 else { 11811 t = parent.predicate("fhir:"+parentType+'.'+name); 11812 } 11813 composeBackboneElement(t, "action", name, element, index); 11814 if (element.hasOperation()) 11815 composeTestScriptSetupActionOperationComponent(t, "TestScript", "operation", element.getOperation(), -1); 11816 } 11817 11818 protected void composeValueSet(Complex parent, String parentType, String name, ValueSet element, int index) { 11819 if (element == null) 11820 return; 11821 Complex t; 11822 if (Utilities.noString(parentType)) 11823 t = parent; 11824 else { 11825 t = parent.predicate("fhir:"+parentType+'.'+name); 11826 } 11827 composeDomainResource(t, "ValueSet", name, element, index); 11828 if (element.hasUrlElement()) 11829 composeUri(t, "ValueSet", "url", element.getUrlElement(), -1); 11830 if (element.hasIdentifier()) 11831 composeIdentifier(t, "ValueSet", "identifier", element.getIdentifier(), -1); 11832 if (element.hasVersionElement()) 11833 composeString(t, "ValueSet", "version", element.getVersionElement(), -1); 11834 if (element.hasNameElement()) 11835 composeString(t, "ValueSet", "name", element.getNameElement(), -1); 11836 if (element.hasStatusElement()) 11837 composeEnum(t, "ValueSet", "status", element.getStatusElement(), -1); 11838 if (element.hasExperimentalElement()) 11839 composeBoolean(t, "ValueSet", "experimental", element.getExperimentalElement(), -1); 11840 if (element.hasPublisherElement()) 11841 composeString(t, "ValueSet", "publisher", element.getPublisherElement(), -1); 11842 for (int i = 0; i < element.getContact().size(); i++) 11843 composeValueSetValueSetContactComponent(t, "ValueSet", "contact", element.getContact().get(i), i); 11844 if (element.hasDateElement()) 11845 composeDateTime(t, "ValueSet", "date", element.getDateElement(), -1); 11846 if (element.hasLockedDateElement()) 11847 composeDate(t, "ValueSet", "lockedDate", element.getLockedDateElement(), -1); 11848 if (element.hasDescriptionElement()) 11849 composeString(t, "ValueSet", "description", element.getDescriptionElement(), -1); 11850 for (int i = 0; i < element.getUseContext().size(); i++) 11851 composeCodeableConcept(t, "ValueSet", "useContext", element.getUseContext().get(i), i); 11852 if (element.hasImmutableElement()) 11853 composeBoolean(t, "ValueSet", "immutable", element.getImmutableElement(), -1); 11854 if (element.hasRequirementsElement()) 11855 composeString(t, "ValueSet", "requirements", element.getRequirementsElement(), -1); 11856 if (element.hasCopyrightElement()) 11857 composeString(t, "ValueSet", "copyright", element.getCopyrightElement(), -1); 11858 if (element.hasExtensibleElement()) 11859 composeBoolean(t, "ValueSet", "extensible", element.getExtensibleElement(), -1); 11860 if (element.hasCompose()) 11861 composeValueSetValueSetComposeComponent(t, "ValueSet", "compose", element.getCompose(), -1); 11862 if (element.hasExpansion()) 11863 composeValueSetValueSetExpansionComponent(t, "ValueSet", "expansion", element.getExpansion(), -1); 11864 } 11865 11866 protected void composeValueSetValueSetContactComponent(Complex parent, String parentType, String name, ValueSet.ValueSetContactComponent element, int index) { 11867 if (element == null) 11868 return; 11869 Complex t; 11870 if (Utilities.noString(parentType)) 11871 t = parent; 11872 else { 11873 t = parent.predicate("fhir:"+parentType+'.'+name); 11874 } 11875 composeBackboneElement(t, "contact", name, element, index); 11876 if (element.hasNameElement()) 11877 composeString(t, "ValueSet", "name", element.getNameElement(), -1); 11878 for (int i = 0; i < element.getTelecom().size(); i++) 11879 composeContactPoint(t, "ValueSet", "telecom", element.getTelecom().get(i), i); 11880 } 11881 11882 protected void composeValueSetValueSetComposeComponent(Complex parent, String parentType, String name, ValueSet.ValueSetComposeComponent element, int index) { 11883 if (element == null) 11884 return; 11885 Complex t; 11886 if (Utilities.noString(parentType)) 11887 t = parent; 11888 else { 11889 t = parent.predicate("fhir:"+parentType+'.'+name); 11890 } 11891 composeBackboneElement(t, "compose", name, element, index); 11892 for (int i = 0; i < element.getImport().size(); i++) 11893 composeUri(t, "ValueSet", "import", element.getImport().get(i), i); 11894 for (int i = 0; i < element.getInclude().size(); i++) 11895 composeValueSetConceptSetComponent(t, "ValueSet", "include", element.getInclude().get(i), i); 11896 for (int i = 0; i < element.getExclude().size(); i++) 11897 composeValueSetConceptSetComponent(t, "ValueSet", "exclude", element.getExclude().get(i), i); 11898 } 11899 11900 protected void composeValueSetConceptSetComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetComponent element, int index) { 11901 if (element == null) 11902 return; 11903 Complex t; 11904 if (Utilities.noString(parentType)) 11905 t = parent; 11906 else { 11907 t = parent.predicate("fhir:"+parentType+'.'+name); 11908 } 11909 composeBackboneElement(t, "include", name, element, index); 11910 if (element.hasSystemElement()) 11911 composeUri(t, "ValueSet", "system", element.getSystemElement(), -1); 11912 if (element.hasVersionElement()) 11913 composeString(t, "ValueSet", "version", element.getVersionElement(), -1); 11914 for (int i = 0; i < element.getConcept().size(); i++) 11915 composeValueSetConceptReferenceComponent(t, "ValueSet", "concept", element.getConcept().get(i), i); 11916 for (int i = 0; i < element.getFilter().size(); i++) 11917 composeValueSetConceptSetFilterComponent(t, "ValueSet", "filter", element.getFilter().get(i), i); 11918 } 11919 11920 protected void composeValueSetConceptReferenceComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceComponent element, int index) { 11921 if (element == null) 11922 return; 11923 Complex t; 11924 if (Utilities.noString(parentType)) 11925 t = parent; 11926 else { 11927 t = parent.predicate("fhir:"+parentType+'.'+name); 11928 } 11929 composeBackboneElement(t, "concept", name, element, index); 11930 if (element.hasCodeElement()) 11931 composeCode(t, "ValueSet", "code", element.getCodeElement(), -1); 11932 if (element.hasDisplayElement()) 11933 composeString(t, "ValueSet", "display", element.getDisplayElement(), -1); 11934 for (int i = 0; i < element.getDesignation().size(); i++) 11935 composeValueSetConceptReferenceDesignationComponent(t, "ValueSet", "designation", element.getDesignation().get(i), i); 11936 } 11937 11938 protected void composeValueSetConceptReferenceDesignationComponent(Complex parent, String parentType, String name, ValueSet.ConceptReferenceDesignationComponent element, int index) { 11939 if (element == null) 11940 return; 11941 Complex t; 11942 if (Utilities.noString(parentType)) 11943 t = parent; 11944 else { 11945 t = parent.predicate("fhir:"+parentType+'.'+name); 11946 } 11947 composeBackboneElement(t, "designation", name, element, index); 11948 if (element.hasLanguageElement()) 11949 composeCode(t, "ValueSet", "language", element.getLanguageElement(), -1); 11950 if (element.hasUse()) 11951 composeCoding(t, "ValueSet", "use", element.getUse(), -1); 11952 if (element.hasValueElement()) 11953 composeString(t, "ValueSet", "value", element.getValueElement(), -1); 11954 } 11955 11956 protected void composeValueSetConceptSetFilterComponent(Complex parent, String parentType, String name, ValueSet.ConceptSetFilterComponent element, int index) { 11957 if (element == null) 11958 return; 11959 Complex t; 11960 if (Utilities.noString(parentType)) 11961 t = parent; 11962 else { 11963 t = parent.predicate("fhir:"+parentType+'.'+name); 11964 } 11965 composeBackboneElement(t, "filter", name, element, index); 11966 if (element.hasPropertyElement()) 11967 composeCode(t, "ValueSet", "property", element.getPropertyElement(), -1); 11968 if (element.hasOpElement()) 11969 composeEnum(t, "ValueSet", "op", element.getOpElement(), -1); 11970 if (element.hasValueElement()) 11971 composeCode(t, "ValueSet", "value", element.getValueElement(), -1); 11972 } 11973 11974 protected void composeValueSetValueSetExpansionComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionComponent element, int index) { 11975 if (element == null) 11976 return; 11977 Complex t; 11978 if (Utilities.noString(parentType)) 11979 t = parent; 11980 else { 11981 t = parent.predicate("fhir:"+parentType+'.'+name); 11982 } 11983 composeBackboneElement(t, "expansion", name, element, index); 11984 if (element.hasIdentifierElement()) 11985 composeUri(t, "ValueSet", "identifier", element.getIdentifierElement(), -1); 11986 if (element.hasTimestampElement()) 11987 composeDateTime(t, "ValueSet", "timestamp", element.getTimestampElement(), -1); 11988 if (element.hasTotalElement()) 11989 composeInteger(t, "ValueSet", "total", element.getTotalElement(), -1); 11990 if (element.hasOffsetElement()) 11991 composeInteger(t, "ValueSet", "offset", element.getOffsetElement(), -1); 11992 for (int i = 0; i < element.getParameter().size(); i++) 11993 composeValueSetValueSetExpansionParameterComponent(t, "ValueSet", "parameter", element.getParameter().get(i), i); 11994 for (int i = 0; i < element.getContains().size(); i++) 11995 composeValueSetValueSetExpansionContainsComponent(t, "ValueSet", "contains", element.getContains().get(i), i); 11996 } 11997 11998 protected void composeValueSetValueSetExpansionParameterComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionParameterComponent element, int index) { 11999 if (element == null) 12000 return; 12001 Complex t; 12002 if (Utilities.noString(parentType)) 12003 t = parent; 12004 else { 12005 t = parent.predicate("fhir:"+parentType+'.'+name); 12006 } 12007 composeBackboneElement(t, "parameter", name, element, index); 12008 if (element.hasNameElement()) 12009 composeString(t, "ValueSet", "name", element.getNameElement(), -1); 12010 if (element.hasValue()) 12011 composeType(t, "ValueSet", "value", element.getValue(), -1); 12012 } 12013 12014 protected void composeValueSetValueSetExpansionContainsComponent(Complex parent, String parentType, String name, ValueSet.ValueSetExpansionContainsComponent element, int index) { 12015 if (element == null) 12016 return; 12017 Complex t; 12018 if (Utilities.noString(parentType)) 12019 t = parent; 12020 else { 12021 t = parent.predicate("fhir:"+parentType+'.'+name); 12022 } 12023 composeBackboneElement(t, "contains", name, element, index); 12024 if (element.hasSystemElement()) 12025 composeUri(t, "ValueSet", "system", element.getSystemElement(), -1); 12026 if (element.hasAbstractElement()) 12027 composeBoolean(t, "ValueSet", "abstract", element.getAbstractElement(), -1); 12028 if (element.hasVersionElement()) 12029 composeString(t, "ValueSet", "version", element.getVersionElement(), -1); 12030 if (element.hasCodeElement()) 12031 composeCode(t, "ValueSet", "code", element.getCodeElement(), -1); 12032 if (element.hasDisplayElement()) 12033 composeString(t, "ValueSet", "display", element.getDisplayElement(), -1); 12034 for (int i = 0; i < element.getContains().size(); i++) 12035 composeValueSetValueSetExpansionContainsComponent(t, "ValueSet", "contains", element.getContains().get(i), i); 12036 } 12037 12038 protected void composeVisionPrescription(Complex parent, String parentType, String name, VisionPrescription element, int index) { 12039 if (element == null) 12040 return; 12041 Complex t; 12042 if (Utilities.noString(parentType)) 12043 t = parent; 12044 else { 12045 t = parent.predicate("fhir:"+parentType+'.'+name); 12046 } 12047 composeDomainResource(t, "VisionPrescription", name, element, index); 12048 for (int i = 0; i < element.getIdentifier().size(); i++) 12049 composeIdentifier(t, "VisionPrescription", "identifier", element.getIdentifier().get(i), i); 12050 if (element.hasDateWrittenElement()) 12051 composeDateTime(t, "VisionPrescription", "dateWritten", element.getDateWrittenElement(), -1); 12052 if (element.hasPatient()) 12053 composeReference(t, "VisionPrescription", "patient", element.getPatient(), -1); 12054 if (element.hasPrescriber()) 12055 composeReference(t, "VisionPrescription", "prescriber", element.getPrescriber(), -1); 12056 if (element.hasEncounter()) 12057 composeReference(t, "VisionPrescription", "encounter", element.getEncounter(), -1); 12058 if (element.hasReason()) 12059 composeType(t, "VisionPrescription", "reason", element.getReason(), -1); 12060 for (int i = 0; i < element.getDispense().size(); i++) 12061 composeVisionPrescriptionVisionPrescriptionDispenseComponent(t, "VisionPrescription", "dispense", element.getDispense().get(i), i); 12062 } 12063 12064 protected void composeVisionPrescriptionVisionPrescriptionDispenseComponent(Complex parent, String parentType, String name, VisionPrescription.VisionPrescriptionDispenseComponent element, int index) { 12065 if (element == null) 12066 return; 12067 Complex t; 12068 if (Utilities.noString(parentType)) 12069 t = parent; 12070 else { 12071 t = parent.predicate("fhir:"+parentType+'.'+name); 12072 } 12073 composeBackboneElement(t, "dispense", name, element, index); 12074 if (element.hasProduct()) 12075 composeCoding(t, "VisionPrescription", "product", element.getProduct(), -1); 12076 if (element.hasEyeElement()) 12077 composeEnum(t, "VisionPrescription", "eye", element.getEyeElement(), -1); 12078 if (element.hasSphereElement()) 12079 composeDecimal(t, "VisionPrescription", "sphere", element.getSphereElement(), -1); 12080 if (element.hasCylinderElement()) 12081 composeDecimal(t, "VisionPrescription", "cylinder", element.getCylinderElement(), -1); 12082 if (element.hasAxisElement()) 12083 composeInteger(t, "VisionPrescription", "axis", element.getAxisElement(), -1); 12084 if (element.hasPrismElement()) 12085 composeDecimal(t, "VisionPrescription", "prism", element.getPrismElement(), -1); 12086 if (element.hasBaseElement()) 12087 composeEnum(t, "VisionPrescription", "base", element.getBaseElement(), -1); 12088 if (element.hasAddElement()) 12089 composeDecimal(t, "VisionPrescription", "add", element.getAddElement(), -1); 12090 if (element.hasPowerElement()) 12091 composeDecimal(t, "VisionPrescription", "power", element.getPowerElement(), -1); 12092 if (element.hasBackCurveElement()) 12093 composeDecimal(t, "VisionPrescription", "backCurve", element.getBackCurveElement(), -1); 12094 if (element.hasDiameterElement()) 12095 composeDecimal(t, "VisionPrescription", "diameter", element.getDiameterElement(), -1); 12096 if (element.hasDuration()) 12097 composeQuantity(t, "VisionPrescription", "duration", element.getDuration(), -1); 12098 if (element.hasColorElement()) 12099 composeString(t, "VisionPrescription", "color", element.getColorElement(), -1); 12100 if (element.hasBrandElement()) 12101 composeString(t, "VisionPrescription", "brand", element.getBrandElement(), -1); 12102 if (element.hasNotesElement()) 12103 composeString(t, "VisionPrescription", "notes", element.getNotesElement(), -1); 12104 } 12105 12106 @Override 12107 protected void composeResource(Complex parent, Resource resource) { 12108 if (resource instanceof Parameters) 12109 composeParameters(parent, null, "Parameters", (Parameters)resource, -1); 12110 else if (resource instanceof Account) 12111 composeAccount(parent, null, "Account", (Account)resource, -1); 12112 else if (resource instanceof AllergyIntolerance) 12113 composeAllergyIntolerance(parent, null, "AllergyIntolerance", (AllergyIntolerance)resource, -1); 12114 else if (resource instanceof Appointment) 12115 composeAppointment(parent, null, "Appointment", (Appointment)resource, -1); 12116 else if (resource instanceof AppointmentResponse) 12117 composeAppointmentResponse(parent, null, "AppointmentResponse", (AppointmentResponse)resource, -1); 12118 else if (resource instanceof AuditEvent) 12119 composeAuditEvent(parent, null, "AuditEvent", (AuditEvent)resource, -1); 12120 else if (resource instanceof Basic) 12121 composeBasic(parent, null, "Basic", (Basic)resource, -1); 12122 else if (resource instanceof Binary) 12123 composeBinary(parent, null, "Binary", (Binary)resource, -1); 12124 else if (resource instanceof BodySite) 12125 composeBodySite(parent, null, "BodySite", (BodySite)resource, -1); 12126 else if (resource instanceof Bundle) 12127 composeBundle(parent, null, "Bundle", (Bundle)resource, -1); 12128 else if (resource instanceof CarePlan) 12129 composeCarePlan(parent, null, "CarePlan", (CarePlan)resource, -1); 12130 else if (resource instanceof CareTeam) 12131 composeCareTeam(parent, null, "CareTeam", (CareTeam)resource, -1); 12132 else if (resource instanceof Claim) 12133 composeClaim(parent, null, "Claim", (Claim)resource, -1); 12134 else if (resource instanceof ClaimResponse) 12135 composeClaimResponse(parent, null, "ClaimResponse", (ClaimResponse)resource, -1); 12136 else if (resource instanceof ClinicalImpression) 12137 composeClinicalImpression(parent, null, "ClinicalImpression", (ClinicalImpression)resource, -1); 12138 else if (resource instanceof CodeSystem) 12139 composeCodeSystem(parent, null, "CodeSystem", (CodeSystem)resource, -1); 12140 else if (resource instanceof Communication) 12141 composeCommunication(parent, null, "Communication", (Communication)resource, -1); 12142 else if (resource instanceof CommunicationRequest) 12143 composeCommunicationRequest(parent, null, "CommunicationRequest", (CommunicationRequest)resource, -1); 12144 else if (resource instanceof CompartmentDefinition) 12145 composeCompartmentDefinition(parent, null, "CompartmentDefinition", (CompartmentDefinition)resource, -1); 12146 else if (resource instanceof Composition) 12147 composeComposition(parent, null, "Composition", (Composition)resource, -1); 12148 else if (resource instanceof ConceptMap) 12149 composeConceptMap(parent, null, "ConceptMap", (ConceptMap)resource, -1); 12150 else if (resource instanceof Condition) 12151 composeCondition(parent, null, "Condition", (Condition)resource, -1); 12152 else if (resource instanceof Conformance) 12153 composeConformance(parent, null, "Conformance", (Conformance)resource, -1); 12154 else if (resource instanceof Contract) 12155 composeContract(parent, null, "Contract", (Contract)resource, -1); 12156 else if (resource instanceof Coverage) 12157 composeCoverage(parent, null, "Coverage", (Coverage)resource, -1); 12158 else if (resource instanceof DataElement) 12159 composeDataElement(parent, null, "DataElement", (DataElement)resource, -1); 12160 else if (resource instanceof DecisionSupportRule) 12161 composeDecisionSupportRule(parent, null, "DecisionSupportRule", (DecisionSupportRule)resource, -1); 12162 else if (resource instanceof DecisionSupportServiceModule) 12163 composeDecisionSupportServiceModule(parent, null, "DecisionSupportServiceModule", (DecisionSupportServiceModule)resource, -1); 12164 else if (resource instanceof DetectedIssue) 12165 composeDetectedIssue(parent, null, "DetectedIssue", (DetectedIssue)resource, -1); 12166 else if (resource instanceof Device) 12167 composeDevice(parent, null, "Device", (Device)resource, -1); 12168 else if (resource instanceof DeviceComponent) 12169 composeDeviceComponent(parent, null, "DeviceComponent", (DeviceComponent)resource, -1); 12170 else if (resource instanceof DeviceMetric) 12171 composeDeviceMetric(parent, null, "DeviceMetric", (DeviceMetric)resource, -1); 12172 else if (resource instanceof DeviceUseRequest) 12173 composeDeviceUseRequest(parent, null, "DeviceUseRequest", (DeviceUseRequest)resource, -1); 12174 else if (resource instanceof DeviceUseStatement) 12175 composeDeviceUseStatement(parent, null, "DeviceUseStatement", (DeviceUseStatement)resource, -1); 12176 else if (resource instanceof DiagnosticOrder) 12177 composeDiagnosticOrder(parent, null, "DiagnosticOrder", (DiagnosticOrder)resource, -1); 12178 else if (resource instanceof DiagnosticReport) 12179 composeDiagnosticReport(parent, null, "DiagnosticReport", (DiagnosticReport)resource, -1); 12180 else if (resource instanceof DocumentManifest) 12181 composeDocumentManifest(parent, null, "DocumentManifest", (DocumentManifest)resource, -1); 12182 else if (resource instanceof DocumentReference) 12183 composeDocumentReference(parent, null, "DocumentReference", (DocumentReference)resource, -1); 12184 else if (resource instanceof EligibilityRequest) 12185 composeEligibilityRequest(parent, null, "EligibilityRequest", (EligibilityRequest)resource, -1); 12186 else if (resource instanceof EligibilityResponse) 12187 composeEligibilityResponse(parent, null, "EligibilityResponse", (EligibilityResponse)resource, -1); 12188 else if (resource instanceof Encounter) 12189 composeEncounter(parent, null, "Encounter", (Encounter)resource, -1); 12190 else if (resource instanceof EnrollmentRequest) 12191 composeEnrollmentRequest(parent, null, "EnrollmentRequest", (EnrollmentRequest)resource, -1); 12192 else if (resource instanceof EnrollmentResponse) 12193 composeEnrollmentResponse(parent, null, "EnrollmentResponse", (EnrollmentResponse)resource, -1); 12194 else if (resource instanceof EpisodeOfCare) 12195 composeEpisodeOfCare(parent, null, "EpisodeOfCare", (EpisodeOfCare)resource, -1); 12196 else if (resource instanceof ExpansionProfile) 12197 composeExpansionProfile(parent, null, "ExpansionProfile", (ExpansionProfile)resource, -1); 12198 else if (resource instanceof ExplanationOfBenefit) 12199 composeExplanationOfBenefit(parent, null, "ExplanationOfBenefit", (ExplanationOfBenefit)resource, -1); 12200 else if (resource instanceof FamilyMemberHistory) 12201 composeFamilyMemberHistory(parent, null, "FamilyMemberHistory", (FamilyMemberHistory)resource, -1); 12202 else if (resource instanceof Flag) 12203 composeFlag(parent, null, "Flag", (Flag)resource, -1); 12204 else if (resource instanceof Goal) 12205 composeGoal(parent, null, "Goal", (Goal)resource, -1); 12206 else if (resource instanceof Group) 12207 composeGroup(parent, null, "Group", (Group)resource, -1); 12208 else if (resource instanceof GuidanceResponse) 12209 composeGuidanceResponse(parent, null, "GuidanceResponse", (GuidanceResponse)resource, -1); 12210 else if (resource instanceof HealthcareService) 12211 composeHealthcareService(parent, null, "HealthcareService", (HealthcareService)resource, -1); 12212 else if (resource instanceof ImagingExcerpt) 12213 composeImagingExcerpt(parent, null, "ImagingExcerpt", (ImagingExcerpt)resource, -1); 12214 else if (resource instanceof ImagingObjectSelection) 12215 composeImagingObjectSelection(parent, null, "ImagingObjectSelection", (ImagingObjectSelection)resource, -1); 12216 else if (resource instanceof ImagingStudy) 12217 composeImagingStudy(parent, null, "ImagingStudy", (ImagingStudy)resource, -1); 12218 else if (resource instanceof Immunization) 12219 composeImmunization(parent, null, "Immunization", (Immunization)resource, -1); 12220 else if (resource instanceof ImmunizationRecommendation) 12221 composeImmunizationRecommendation(parent, null, "ImmunizationRecommendation", (ImmunizationRecommendation)resource, -1); 12222 else if (resource instanceof ImplementationGuide) 12223 composeImplementationGuide(parent, null, "ImplementationGuide", (ImplementationGuide)resource, -1); 12224 else if (resource instanceof Library) 12225 composeLibrary(parent, null, "Library", (Library)resource, -1); 12226 else if (resource instanceof Linkage) 12227 composeLinkage(parent, null, "Linkage", (Linkage)resource, -1); 12228 else if (resource instanceof ListResource) 12229 composeListResource(parent, null, "ListResource", (ListResource)resource, -1); 12230 else if (resource instanceof Location) 12231 composeLocation(parent, null, "Location", (Location)resource, -1); 12232 else if (resource instanceof Measure) 12233 composeMeasure(parent, null, "Measure", (Measure)resource, -1); 12234 else if (resource instanceof MeasureReport) 12235 composeMeasureReport(parent, null, "MeasureReport", (MeasureReport)resource, -1); 12236 else if (resource instanceof Media) 12237 composeMedia(parent, null, "Media", (Media)resource, -1); 12238 else if (resource instanceof Medication) 12239 composeMedication(parent, null, "Medication", (Medication)resource, -1); 12240 else if (resource instanceof MedicationAdministration) 12241 composeMedicationAdministration(parent, null, "MedicationAdministration", (MedicationAdministration)resource, -1); 12242 else if (resource instanceof MedicationDispense) 12243 composeMedicationDispense(parent, null, "MedicationDispense", (MedicationDispense)resource, -1); 12244 else if (resource instanceof MedicationOrder) 12245 composeMedicationOrder(parent, null, "MedicationOrder", (MedicationOrder)resource, -1); 12246 else if (resource instanceof MedicationStatement) 12247 composeMedicationStatement(parent, null, "MedicationStatement", (MedicationStatement)resource, -1); 12248 else if (resource instanceof MessageHeader) 12249 composeMessageHeader(parent, null, "MessageHeader", (MessageHeader)resource, -1); 12250 else if (resource instanceof ModuleDefinition) 12251 composeModuleDefinition(parent, null, "ModuleDefinition", (ModuleDefinition)resource, -1); 12252 else if (resource instanceof NamingSystem) 12253 composeNamingSystem(parent, null, "NamingSystem", (NamingSystem)resource, -1); 12254 else if (resource instanceof NutritionOrder) 12255 composeNutritionOrder(parent, null, "NutritionOrder", (NutritionOrder)resource, -1); 12256 else if (resource instanceof Observation) 12257 composeObservation(parent, null, "Observation", (Observation)resource, -1); 12258 else if (resource instanceof OperationDefinition) 12259 composeOperationDefinition(parent, null, "OperationDefinition", (OperationDefinition)resource, -1); 12260 else if (resource instanceof OperationOutcome) 12261 composeOperationOutcome(parent, null, "OperationOutcome", (OperationOutcome)resource, -1); 12262 else if (resource instanceof Order) 12263 composeOrder(parent, null, "Order", (Order)resource, -1); 12264 else if (resource instanceof OrderResponse) 12265 composeOrderResponse(parent, null, "OrderResponse", (OrderResponse)resource, -1); 12266 else if (resource instanceof OrderSet) 12267 composeOrderSet(parent, null, "OrderSet", (OrderSet)resource, -1); 12268 else if (resource instanceof Organization) 12269 composeOrganization(parent, null, "Organization", (Organization)resource, -1); 12270 else if (resource instanceof Patient) 12271 composePatient(parent, null, "Patient", (Patient)resource, -1); 12272 else if (resource instanceof PaymentNotice) 12273 composePaymentNotice(parent, null, "PaymentNotice", (PaymentNotice)resource, -1); 12274 else if (resource instanceof PaymentReconciliation) 12275 composePaymentReconciliation(parent, null, "PaymentReconciliation", (PaymentReconciliation)resource, -1); 12276 else if (resource instanceof Person) 12277 composePerson(parent, null, "Person", (Person)resource, -1); 12278 else if (resource instanceof Practitioner) 12279 composePractitioner(parent, null, "Practitioner", (Practitioner)resource, -1); 12280 else if (resource instanceof PractitionerRole) 12281 composePractitionerRole(parent, null, "PractitionerRole", (PractitionerRole)resource, -1); 12282 else if (resource instanceof Procedure) 12283 composeProcedure(parent, null, "Procedure", (Procedure)resource, -1); 12284 else if (resource instanceof ProcedureRequest) 12285 composeProcedureRequest(parent, null, "ProcedureRequest", (ProcedureRequest)resource, -1); 12286 else if (resource instanceof ProcessRequest) 12287 composeProcessRequest(parent, null, "ProcessRequest", (ProcessRequest)resource, -1); 12288 else if (resource instanceof ProcessResponse) 12289 composeProcessResponse(parent, null, "ProcessResponse", (ProcessResponse)resource, -1); 12290 else if (resource instanceof Protocol) 12291 composeProtocol(parent, null, "Protocol", (Protocol)resource, -1); 12292 else if (resource instanceof Provenance) 12293 composeProvenance(parent, null, "Provenance", (Provenance)resource, -1); 12294 else if (resource instanceof Questionnaire) 12295 composeQuestionnaire(parent, null, "Questionnaire", (Questionnaire)resource, -1); 12296 else if (resource instanceof QuestionnaireResponse) 12297 composeQuestionnaireResponse(parent, null, "QuestionnaireResponse", (QuestionnaireResponse)resource, -1); 12298 else if (resource instanceof ReferralRequest) 12299 composeReferralRequest(parent, null, "ReferralRequest", (ReferralRequest)resource, -1); 12300 else if (resource instanceof RelatedPerson) 12301 composeRelatedPerson(parent, null, "RelatedPerson", (RelatedPerson)resource, -1); 12302 else if (resource instanceof RiskAssessment) 12303 composeRiskAssessment(parent, null, "RiskAssessment", (RiskAssessment)resource, -1); 12304 else if (resource instanceof Schedule) 12305 composeSchedule(parent, null, "Schedule", (Schedule)resource, -1); 12306 else if (resource instanceof SearchParameter) 12307 composeSearchParameter(parent, null, "SearchParameter", (SearchParameter)resource, -1); 12308 else if (resource instanceof Sequence) 12309 composeSequence(parent, null, "Sequence", (Sequence)resource, -1); 12310 else if (resource instanceof Slot) 12311 composeSlot(parent, null, "Slot", (Slot)resource, -1); 12312 else if (resource instanceof Specimen) 12313 composeSpecimen(parent, null, "Specimen", (Specimen)resource, -1); 12314 else if (resource instanceof StructureDefinition) 12315 composeStructureDefinition(parent, null, "StructureDefinition", (StructureDefinition)resource, -1); 12316 else if (resource instanceof StructureMap) 12317 composeStructureMap(parent, null, "StructureMap", (StructureMap)resource, -1); 12318 else if (resource instanceof Subscription) 12319 composeSubscription(parent, null, "Subscription", (Subscription)resource, -1); 12320 else if (resource instanceof Substance) 12321 composeSubstance(parent, null, "Substance", (Substance)resource, -1); 12322 else if (resource instanceof SupplyDelivery) 12323 composeSupplyDelivery(parent, null, "SupplyDelivery", (SupplyDelivery)resource, -1); 12324 else if (resource instanceof SupplyRequest) 12325 composeSupplyRequest(parent, null, "SupplyRequest", (SupplyRequest)resource, -1); 12326 else if (resource instanceof Task) 12327 composeTask(parent, null, "Task", (Task)resource, -1); 12328 else if (resource instanceof TestScript) 12329 composeTestScript(parent, null, "TestScript", (TestScript)resource, -1); 12330 else if (resource instanceof ValueSet) 12331 composeValueSet(parent, null, "ValueSet", (ValueSet)resource, -1); 12332 else if (resource instanceof VisionPrescription) 12333 composeVisionPrescription(parent, null, "VisionPrescription", (VisionPrescription)resource, -1); 12334 else 12335 throw new Error("Unhandled resource type "+resource.getClass().getName()); 12336 } 12337 12338 protected void composeType(Complex parent, String parentType, String name, Type value, int index) { 12339 if (value == null) 12340 return; 12341 else if (value instanceof MarkdownType) 12342 composeMarkdown(parent, parentType, name, (MarkdownType)value, index); 12343 else if (value instanceof IntegerType) 12344 composeInteger(parent, parentType, name, (IntegerType)value, index); 12345 else if (value instanceof DateTimeType) 12346 composeDateTime(parent, parentType, name, (DateTimeType)value, index); 12347 else if (value instanceof UnsignedIntType) 12348 composeUnsignedInt(parent, parentType, name, (UnsignedIntType)value, index); 12349 else if (value instanceof CodeType) 12350 composeCode(parent, parentType, name, (CodeType)value, index); 12351 else if (value instanceof DateType) 12352 composeDate(parent, parentType, name, (DateType)value, index); 12353 else if (value instanceof DecimalType) 12354 composeDecimal(parent, parentType, name, (DecimalType)value, index); 12355 else if (value instanceof UriType) 12356 composeUri(parent, parentType, name, (UriType)value, index); 12357 else if (value instanceof IdType) 12358 composeId(parent, parentType, name, (IdType)value, index); 12359 else if (value instanceof Base64BinaryType) 12360 composeBase64Binary(parent, parentType, name, (Base64BinaryType)value, index); 12361 else if (value instanceof TimeType) 12362 composeTime(parent, parentType, name, (TimeType)value, index); 12363 else if (value instanceof OidType) 12364 composeOid(parent, parentType, name, (OidType)value, index); 12365 else if (value instanceof PositiveIntType) 12366 composePositiveInt(parent, parentType, name, (PositiveIntType)value, index); 12367 else if (value instanceof StringType) 12368 composeString(parent, parentType, name, (StringType)value, index); 12369 else if (value instanceof BooleanType) 12370 composeBoolean(parent, parentType, name, (BooleanType)value, index); 12371 else if (value instanceof UuidType) 12372 composeUuid(parent, parentType, name, (UuidType)value, index); 12373 else if (value instanceof InstantType) 12374 composeInstant(parent, parentType, name, (InstantType)value, index); 12375 else if (value instanceof Extension) 12376 composeExtension(parent, parentType, name, (Extension)value, index); 12377 else if (value instanceof Narrative) 12378 composeNarrative(parent, parentType, name, (Narrative)value, index); 12379 else if (value instanceof Period) 12380 composePeriod(parent, parentType, name, (Period)value, index); 12381 else if (value instanceof Coding) 12382 composeCoding(parent, parentType, name, (Coding)value, index); 12383 else if (value instanceof Range) 12384 composeRange(parent, parentType, name, (Range)value, index); 12385 else if (value instanceof Quantity) 12386 composeQuantity(parent, parentType, name, (Quantity)value, index); 12387 else if (value instanceof Attachment) 12388 composeAttachment(parent, parentType, name, (Attachment)value, index); 12389 else if (value instanceof Ratio) 12390 composeRatio(parent, parentType, name, (Ratio)value, index); 12391 else if (value instanceof Annotation) 12392 composeAnnotation(parent, parentType, name, (Annotation)value, index); 12393 else if (value instanceof SampledData) 12394 composeSampledData(parent, parentType, name, (SampledData)value, index); 12395 else if (value instanceof Reference) 12396 composeReference(parent, parentType, name, (Reference)value, index); 12397 else if (value instanceof CodeableConcept) 12398 composeCodeableConcept(parent, parentType, name, (CodeableConcept)value, index); 12399 else if (value instanceof Identifier) 12400 composeIdentifier(parent, parentType, name, (Identifier)value, index); 12401 else if (value instanceof Signature) 12402 composeSignature(parent, parentType, name, (Signature)value, index); 12403 else if (value instanceof TriggerDefinition) 12404 composeTriggerDefinition(parent, parentType, name, (TriggerDefinition)value, index); 12405 else if (value instanceof ElementDefinition) 12406 composeElementDefinition(parent, parentType, name, (ElementDefinition)value, index); 12407 else if (value instanceof Timing) 12408 composeTiming(parent, parentType, name, (Timing)value, index); 12409 else if (value instanceof ModuleMetadata) 12410 composeModuleMetadata(parent, parentType, name, (ModuleMetadata)value, index); 12411 else if (value instanceof ActionDefinition) 12412 composeActionDefinition(parent, parentType, name, (ActionDefinition)value, index); 12413 else if (value instanceof Address) 12414 composeAddress(parent, parentType, name, (Address)value, index); 12415 else if (value instanceof HumanName) 12416 composeHumanName(parent, parentType, name, (HumanName)value, index); 12417 else if (value instanceof DataRequirement) 12418 composeDataRequirement(parent, parentType, name, (DataRequirement)value, index); 12419 else if (value instanceof Meta) 12420 composeMeta(parent, parentType, name, (Meta)value, index); 12421 else if (value instanceof ParameterDefinition) 12422 composeParameterDefinition(parent, parentType, name, (ParameterDefinition)value, index); 12423 else if (value instanceof ContactPoint) 12424 composeContactPoint(parent, parentType, name, (ContactPoint)value, index); 12425 else 12426 throw new Error("Unhandled type"); 12427 } 12428 12429}