001/*- 002 * #%L 003 * HAPI FHIR - Converter 004 * %% 005 * Copyright (C) 2014 - 2025 Smile CDR, Inc. 006 * %% 007 * Licensed under the Apache License, Version 2.0 (the "License"); 008 * you may not use this file except in compliance with the License. 009 * You may obtain a copy of the License at 010 * 011 * http://www.apache.org/licenses/LICENSE-2.0 012 * 013 * Unless required by applicable law or agreed to in writing, software 014 * distributed under the License is distributed on an "AS IS" BASIS, 015 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 016 * See the License for the specific language governing permissions and 017 * limitations under the License. 018 * #L% 019 */ 020package ca.uhn.hapi.converters.canonical; 021 022import ca.uhn.fhir.context.BaseRuntimeChildDefinition; 023import ca.uhn.fhir.context.FhirContext; 024import ca.uhn.fhir.context.FhirVersionEnum; 025import ca.uhn.fhir.i18n.Msg; 026import ca.uhn.fhir.model.dstu2.composite.CodeableConceptDt; 027import ca.uhn.fhir.model.dstu2.composite.CodingDt; 028import ca.uhn.fhir.util.HapiExtensions; 029import jakarta.annotation.Nonnull; 030import org.apache.commons.lang3.StringUtils; 031import org.hl7.fhir.convertors.advisors.impl.BaseAdvisor_10_40; 032import org.hl7.fhir.convertors.advisors.impl.BaseAdvisor_10_50; 033import org.hl7.fhir.convertors.advisors.impl.BaseAdvisor_14_40; 034import org.hl7.fhir.convertors.advisors.impl.BaseAdvisor_14_50; 035import org.hl7.fhir.convertors.advisors.impl.BaseAdvisor_30_40; 036import org.hl7.fhir.convertors.advisors.impl.BaseAdvisor_30_50; 037import org.hl7.fhir.convertors.advisors.impl.BaseAdvisor_40_50; 038import org.hl7.fhir.convertors.advisors.impl.BaseAdvisor_43_50; 039import org.hl7.fhir.convertors.factory.VersionConvertorFactory_10_40; 040import org.hl7.fhir.convertors.factory.VersionConvertorFactory_10_50; 041import org.hl7.fhir.convertors.factory.VersionConvertorFactory_14_40; 042import org.hl7.fhir.convertors.factory.VersionConvertorFactory_14_50; 043import org.hl7.fhir.convertors.factory.VersionConvertorFactory_30_40; 044import org.hl7.fhir.convertors.factory.VersionConvertorFactory_30_50; 045import org.hl7.fhir.convertors.factory.VersionConvertorFactory_40_50; 046import org.hl7.fhir.convertors.factory.VersionConvertorFactory_43_50; 047import org.hl7.fhir.dstu2.model.Resource; 048import org.hl7.fhir.instance.model.api.IBase; 049import org.hl7.fhir.instance.model.api.IBaseCoding; 050import org.hl7.fhir.instance.model.api.IBaseConformance; 051import org.hl7.fhir.instance.model.api.IBaseDatatype; 052import org.hl7.fhir.instance.model.api.IBaseParameters; 053import org.hl7.fhir.instance.model.api.IBaseResource; 054import org.hl7.fhir.instance.model.api.IPrimitiveType; 055import org.hl7.fhir.r4.model.AuditEvent; 056import org.hl7.fhir.r4.model.CodeSystem; 057import org.hl7.fhir.r4.model.CodeableConcept; 058import org.hl7.fhir.r4.model.Coding; 059import org.hl7.fhir.r4.model.ConceptMap; 060import org.hl7.fhir.r4.model.Parameters; 061import org.hl7.fhir.r4.model.ValueSet; 062import org.hl7.fhir.r5.model.CapabilityStatement; 063import org.hl7.fhir.r5.model.CodeType; 064import org.hl7.fhir.r5.model.Enumerations; 065import org.hl7.fhir.r5.model.PackageInformation; 066import org.hl7.fhir.r5.model.SearchParameter; 067import org.hl7.fhir.r5.model.StructureDefinition; 068import org.hl7.fhir.r5.model.SubscriptionTopic; 069 070import java.util.Date; 071import java.util.List; 072import java.util.Objects; 073import java.util.stream.Collectors; 074 075import static org.apache.commons.lang3.StringUtils.isBlank; 076 077/** 078 * This class converts versions of various resources to/from a canonical version 079 * of the resource. The specific version that is considered canonical is arbitrary 080 * for historical reasons, generally it will be R4 or R5 but this varies by resource 081 * type. 082 * <p> 083 * This class is an internal HAPI FHIR API and can change without notice at any time. 084 * Use with caution! 085 * </p> 086 */ 087public class VersionCanonicalizer { 088 089 private static final BaseAdvisor_30_50 ADVISOR_30_50 = new BaseAdvisor_30_50(false); 090 private static final BaseAdvisor_30_40 ADVISOR_30_40 = new BaseAdvisor_30_40(false); 091 private static final BaseAdvisor_10_40 ADVISOR_10_40 = new BaseAdvisor_10_40(false); 092 private static final BaseAdvisor_10_50 ADVISOR_10_50 = new BaseAdvisor_10_50(false); 093 private static final BaseAdvisor_40_50 ADVISOR_40_50 = new BaseAdvisor_40_50(false); 094 private static final BaseAdvisor_43_50 ADVISOR_43_50 = new BaseAdvisor_43_50(false); 095 private static final BaseAdvisor_14_40 ADVISOR_14_40 = new BaseAdvisor_14_40(false); 096 private static final BaseAdvisor_14_50 ADVISOR_14_50 = new BaseAdvisor_14_50(false); 097 098 private final IStrategy myStrategy; 099 private final FhirContext myContext; 100 101 public VersionCanonicalizer(FhirVersionEnum theTargetVersion) { 102 this(FhirContext.forCached(theTargetVersion)); 103 } 104 105 public VersionCanonicalizer(FhirContext theTargetContext) { 106 myContext = theTargetContext; 107 FhirVersionEnum targetVersion = theTargetContext.getVersion().getVersion(); 108 switch (targetVersion) { 109 case DSTU2: 110 myStrategy = new Dstu2Strategy(false); 111 break; 112 case DSTU2_HL7ORG: 113 myStrategy = new Dstu2Strategy(true); 114 break; 115 case DSTU2_1: 116 myStrategy = new Dstu21Strategy(); 117 break; 118 case DSTU3: 119 myStrategy = new Dstu3Strategy(); 120 break; 121 case R4: 122 myStrategy = new R4Strategy(); 123 break; 124 case R4B: 125 myStrategy = new R4BStrategy(); 126 break; 127 case R5: 128 myStrategy = new R5Strategy(); 129 break; 130 default: 131 throw new IllegalStateException(Msg.code(193) + "Can't handle version: " + targetVersion); 132 } 133 } 134 135 /** 136 * Canonical version: R5 137 */ 138 public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) { 139 return myStrategy.capabilityStatementToCanonical(theCapabilityStatement); 140 } 141 142 /** 143 * Canonical version: R5 144 */ 145 public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theCapabilityStatement) { 146 return myStrategy.capabilityStatementFromCanonical(theCapabilityStatement); 147 } 148 149 /** 150 * Canonical version: R4 151 */ 152 public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) { 153 if (theCodeableConcept == null) { 154 return null; 155 } 156 return myStrategy.codeableConceptToCanonical(theCodeableConcept); 157 } 158 159 /** 160 * Canonical version: R4 161 */ 162 public Coding codingToCanonical(IBaseCoding theCodingToValidate) { 163 if (theCodingToValidate == null) { 164 return null; 165 } 166 return myStrategy.codingToCanonical(theCodingToValidate); 167 } 168 169 /** 170 * Canonical version: R4 171 */ 172 public ValueSet valueSetToCanonical(IBaseResource theValueSet) { 173 if (theValueSet == null) { 174 return null; 175 } 176 return myStrategy.valueSetToCanonical(theValueSet); 177 } 178 179 /** 180 * Canonical version: R4 181 */ 182 public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) { 183 return myStrategy.codeSystemToCanonical(theCodeSystem); 184 } 185 186 /** 187 * Canonical version: R4 188 */ 189 public IBaseResource valueSetFromCanonical(ValueSet theValueSet) { 190 return myStrategy.valueSetFromCanonical(theValueSet); 191 } 192 193 /** 194 * Canonical version: R4 195 */ 196 public IBaseResource codeSystemFromCanonical(CodeSystem theCodeSystem) { 197 return myStrategy.codeSystemFromCanonical(theCodeSystem); 198 } 199 200 /** 201 * Canonical version: R4 202 */ 203 public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) { 204 return myStrategy.conceptMapToCanonical(theConceptMap); 205 } 206 207 /** 208 * Canonical version: R5 209 * <p> 210 * Note that this method will look for any nonstandard resource types specified in 211 * {@literal SearchParameter.base} or {@literal SearchParameter.target} and move them into 212 * extensions with the URLs {@link HapiExtensions#EXTENSION_SEARCHPARAM_CUSTOM_BASE_RESOURCE} 213 * and {@link HapiExtensions#EXTENSION_SEARCHPARAM_CUSTOM_TARGET_RESOURCE} respectively. If any 214 * nonstandard resource types are found, all resource types in the respective list are moved into 215 * the extension (including standard types) and the source list is cleared. 216 */ 217 public <T extends IBaseResource> SearchParameter searchParameterToCanonical(T theSearchParameter) { 218 219 /* 220 * The R4 model allows custom types to be put into SearchParameter.base and 221 * SearchParameter.target because those fields use a simple CodeType. But 222 * in R5 it uses an Enumeration, so it's not actually possible to put custom 223 * resource types into those fields. This means that the version converter fails 224 * with an exception unless we remove those values from those fields before 225 * conversion. However, we don't want to affect the state of the originally 226 * passed in resource since that may affect other things. So, we clone 227 * it first. This is a pain in the butt, but there doesn't seem to be any 228 * better option. 229 */ 230 T input = myContext.newTerser().clone(theSearchParameter); 231 232 List<String> baseExtensionValues = 233 extractNonStandardSearchParameterListAndClearSourceIfAnyArePresent(input, "base"); 234 List<String> targetExtensionValues = 235 extractNonStandardSearchParameterListAndClearSourceIfAnyArePresent(input, "target"); 236 237 SearchParameter retVal = myStrategy.searchParameterToCanonical(input); 238 239 baseExtensionValues.forEach( 240 t -> retVal.addExtension(HapiExtensions.EXTENSION_SEARCHPARAM_CUSTOM_BASE_RESOURCE, new CodeType(t))); 241 targetExtensionValues.forEach( 242 t -> retVal.addExtension(HapiExtensions.EXTENSION_SEARCHPARAM_CUSTOM_TARGET_RESOURCE, new CodeType(t))); 243 return retVal; 244 } 245 246 public IBaseResource searchParameterFromCanonical(SearchParameter theSearchParameter) { 247 return myStrategy.searchParameterFromCanonical(theSearchParameter); 248 } 249 250 public IBaseParameters parametersFromCanonical(Parameters theParameters) { 251 return myStrategy.parametersFromCanonical(theParameters); 252 } 253 254 public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) { 255 StructureDefinition retVal = myStrategy.structureDefinitionToCanonical(theResource); 256 String packageUserData = (String) theResource.getUserData("package"); 257 if (packageUserData != null) { 258 retVal.setUserData("package", packageUserData); 259 retVal.setSourcePackage(new PackageInformation( 260 packageUserData, theResource.getStructureFhirVersionEnum().getFhirVersionString(), new Date())); 261 } 262 return retVal; 263 } 264 265 public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) { 266 return myStrategy.structureDefinitionFromCanonical(theResource); 267 } 268 269 public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) { 270 return myStrategy.valueSetFromValidatorCanonical(theResource); 271 } 272 273 public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) { 274 return myStrategy.resourceToValidatorCanonical(theResource); 275 } 276 277 public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) { 278 return myStrategy.valueSetToValidatorCanonical(theResource); 279 } 280 281 public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) { 282 return myStrategy.codeSystemToValidatorCanonical(theResource); 283 } 284 285 public IBaseResource auditEventFromCanonical(AuditEvent theResource) { 286 return myStrategy.auditEventFromCanonical(theResource); 287 } 288 289 @Nonnull 290 private List<String> extractNonStandardSearchParameterListAndClearSourceIfAnyArePresent( 291 IBaseResource theSearchParameter, String theChildName) { 292 293 BaseRuntimeChildDefinition child = 294 myContext.getResourceDefinition(theSearchParameter).getChildByName(theChildName); 295 List<IBase> baseList = child.getAccessor().getValues(theSearchParameter); 296 297 List<String> baseExtensionValues = baseList.stream() 298 .filter(Objects::nonNull) 299 .filter(t -> t instanceof IPrimitiveType) 300 .map(t -> (IPrimitiveType<?>) t) 301 .map(IPrimitiveType::getValueAsString) 302 .filter(StringUtils::isNotBlank) 303 .collect(Collectors.toList()); 304 if (baseExtensionValues.stream().allMatch(Enumerations.VersionIndependentResourceTypesAll::isValidCode)) { 305 baseExtensionValues.clear(); 306 } else { 307 baseList.clear(); 308 } 309 return baseExtensionValues; 310 } 311 312 public SubscriptionTopic subscriptionTopicToCanonical(IBaseResource theResource) { 313 return SubscriptionTopicCanonicalizer.canonicalizeTopic(myContext, theResource); 314 } 315 316 public IBaseResource conceptMapFromCanonical(ConceptMap theConceptMap) { 317 return myStrategy.conceptMapFromCanonical(theConceptMap); 318 } 319 320 private interface IStrategy { 321 322 CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement); 323 324 Coding codingToCanonical(IBaseCoding theCoding); 325 326 CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept); 327 328 ValueSet valueSetToCanonical(IBaseResource theValueSet); 329 330 CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem); 331 332 IBaseResource valueSetFromCanonical(ValueSet theValueSet); 333 334 IBaseResource codeSystemFromCanonical(CodeSystem theCodeSystem); 335 336 ConceptMap conceptMapToCanonical(IBaseResource theConceptMap); 337 338 IBaseResource conceptMapFromCanonical(ConceptMap theConceptMap); 339 340 SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter); 341 342 IBaseParameters parametersFromCanonical(Parameters theParameters); 343 344 StructureDefinition structureDefinitionToCanonical(IBaseResource theResource); 345 346 IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource); 347 348 IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource); 349 350 org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource); 351 352 org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource); 353 354 org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource); 355 356 IBaseResource searchParameterFromCanonical(SearchParameter theResource); 357 358 IBaseResource auditEventFromCanonical(AuditEvent theResource); 359 360 IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource); 361 } 362 363 private static class Dstu2Strategy implements IStrategy { 364 365 private final FhirContext myDstu2Hl7OrgContext = FhirContext.forDstu2Hl7OrgCached(); 366 367 private final FhirContext myDstu2Context = FhirContext.forDstu2Cached(); 368 private final boolean myHl7OrgStructures; 369 370 public Dstu2Strategy(boolean theHl7OrgStructures) { 371 myHl7OrgStructures = theHl7OrgStructures; 372 } 373 374 @Override 375 public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) { 376 org.hl7.fhir.dstu2.model.Resource reencoded = reencodeToHl7Org(theCapabilityStatement); 377 return (CapabilityStatement) VersionConvertorFactory_10_50.convertResource(reencoded, ADVISOR_10_50); 378 } 379 380 @Override 381 public Coding codingToCanonical(IBaseCoding theCoding) { 382 CodingDt coding = (CodingDt) theCoding; 383 Coding retVal = new Coding(); 384 retVal.setCode(coding.getCode()); 385 retVal.setSystem(coding.getSystem()); 386 retVal.setDisplay(coding.getDisplay()); 387 retVal.setVersion(coding.getVersion()); 388 if (!coding.getUserSelectedElement().isEmpty()) { 389 retVal.setUserSelected(coding.getUserSelected()); 390 } 391 392 return retVal; 393 } 394 395 @Override 396 public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) { 397 CodeableConceptDt codeableConcept = (CodeableConceptDt) theCodeableConcept; 398 399 CodeableConcept retVal = new CodeableConcept(); 400 retVal.setText(codeableConcept.getText()); 401 for (CodingDt next : codeableConcept.getCoding()) { 402 retVal.addCoding(codingToCanonical(next)); 403 } 404 405 return retVal; 406 } 407 408 @Override 409 public ValueSet valueSetToCanonical(IBaseResource theValueSet) { 410 org.hl7.fhir.dstu2.model.Resource reencoded = reencodeToHl7Org(theValueSet); 411 return (ValueSet) VersionConvertorFactory_10_40.convertResource(reencoded, ADVISOR_10_40); 412 } 413 414 @Override 415 public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) { 416 CodeSystem retVal = new CodeSystem(); 417 418 ca.uhn.fhir.model.dstu2.resource.ValueSet input = (ca.uhn.fhir.model.dstu2.resource.ValueSet) theCodeSystem; 419 retVal.setUrl(input.getUrl()); 420 421 for (ca.uhn.fhir.model.dstu2.resource.ValueSet.CodeSystemConcept next : 422 input.getCodeSystem().getConcept()) { 423 translateAndAddConcept(next, retVal.getConcept()); 424 } 425 426 return retVal; 427 } 428 429 private void translateAndAddConcept( 430 ca.uhn.fhir.model.dstu2.resource.ValueSet.CodeSystemConcept theSource, 431 List<CodeSystem.ConceptDefinitionComponent> theTarget) { 432 CodeSystem.ConceptDefinitionComponent targetConcept = new CodeSystem.ConceptDefinitionComponent(); 433 targetConcept.setCode(theSource.getCode()); 434 targetConcept.setDisplay(theSource.getDisplay()); 435 436 for (ca.uhn.fhir.model.dstu2.resource.ValueSet.CodeSystemConceptDesignation next : 437 theSource.getDesignation()) { 438 CodeSystem.ConceptDefinitionDesignationComponent targetDesignation = targetConcept.addDesignation(); 439 targetDesignation.setLanguage(next.getLanguage()); 440 targetDesignation.setValue(next.getValue()); 441 if (next.getUse() != null) { 442 targetDesignation.setUse(codingToCanonical(next.getUse())); 443 } 444 } 445 446 for (ca.uhn.fhir.model.dstu2.resource.ValueSet.CodeSystemConcept nextChild : theSource.getConcept()) { 447 translateAndAddConcept(nextChild, targetConcept.getConcept()); 448 } 449 450 theTarget.add(targetConcept); 451 } 452 453 @Override 454 public IBaseResource valueSetFromCanonical(ValueSet theValueSet) { 455 Resource valueSetDstu2Hl7Org = VersionConvertorFactory_10_40.convertResource(theValueSet, ADVISOR_10_40); 456 return reencodeFromHl7Org(valueSetDstu2Hl7Org); 457 } 458 459 @Override 460 public IBaseResource codeSystemFromCanonical(CodeSystem theCodeSystem) { 461 Resource codeSystemDstu2Hl7Org = 462 VersionConvertorFactory_10_40.convertResource(theCodeSystem, ADVISOR_10_40); 463 return reencodeFromHl7Org(codeSystemDstu2Hl7Org); 464 } 465 466 @Override 467 public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) { 468 org.hl7.fhir.dstu2.model.Resource reencoded = reencodeToHl7Org(theConceptMap); 469 return (ConceptMap) VersionConvertorFactory_10_40.convertResource(reencoded, ADVISOR_10_40); 470 } 471 472 @Override 473 public IBaseResource conceptMapFromCanonical(ConceptMap theConceptMap) { 474 Resource codeSystemDstu2Hl7Org = 475 VersionConvertorFactory_10_40.convertResource(theConceptMap, ADVISOR_10_40); 476 return reencodeFromHl7Org(codeSystemDstu2Hl7Org); 477 } 478 479 @Override 480 public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) { 481 org.hl7.fhir.dstu2.model.SearchParameter reencoded = 482 (org.hl7.fhir.dstu2.model.SearchParameter) reencodeToHl7Org(theSearchParameter); 483 SearchParameter retVal = 484 (SearchParameter) VersionConvertorFactory_10_50.convertResource(reencoded, ADVISOR_10_50); 485 if (isBlank(retVal.getExpression())) { 486 retVal.setExpression(reencoded.getXpath()); 487 } 488 return retVal; 489 } 490 491 @Override 492 public IBaseParameters parametersFromCanonical(Parameters theParameters) { 493 Resource converted = VersionConvertorFactory_10_40.convertResource(theParameters, ADVISOR_10_40); 494 return (IBaseParameters) reencodeFromHl7Org(converted); 495 } 496 497 @Override 498 public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) { 499 org.hl7.fhir.dstu2.model.Resource reencoded = reencodeToHl7Org(theResource); 500 return (StructureDefinition) VersionConvertorFactory_10_50.convertResource(reencoded, ADVISOR_10_50); 501 } 502 503 @Override 504 public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) { 505 Resource converted = VersionConvertorFactory_10_50.convertResource(theResource, ADVISOR_10_50); 506 return reencodeFromHl7Org(converted); 507 } 508 509 @Override 510 public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) { 511 Resource converted = VersionConvertorFactory_10_50.convertResource(theResource, ADVISOR_10_50); 512 return reencodeFromHl7Org(converted); 513 } 514 515 @Override 516 public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) { 517 org.hl7.fhir.dstu2.model.Resource reencoded = reencodeToHl7Org(theResource); 518 return VersionConvertorFactory_10_50.convertResource(reencoded, ADVISOR_10_50); 519 } 520 521 @Override 522 public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) { 523 org.hl7.fhir.dstu2.model.Resource reencoded = reencodeToHl7Org(theResource); 524 return (org.hl7.fhir.r5.model.ValueSet) 525 VersionConvertorFactory_10_50.convertResource(reencoded, ADVISOR_10_50); 526 } 527 528 @Override 529 public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) { 530 org.hl7.fhir.dstu2.model.Resource reencoded = reencodeToHl7Org(theResource); 531 return (org.hl7.fhir.r5.model.CodeSystem) 532 VersionConvertorFactory_10_50.convertResource(reencoded, ADVISOR_10_50); 533 } 534 535 @Override 536 public IBaseResource auditEventFromCanonical(AuditEvent theResource) { 537 Resource hl7Org = VersionConvertorFactory_10_40.convertResource(theResource, ADVISOR_10_40); 538 return reencodeFromHl7Org(hl7Org); 539 } 540 541 @Override 542 public IBaseResource searchParameterFromCanonical(SearchParameter theResource) { 543 Resource resource = VersionConvertorFactory_10_50.convertResource(theResource, ADVISOR_10_50); 544 return reencodeFromHl7Org(resource); 545 } 546 547 @Override 548 public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) { 549 Resource converted = VersionConvertorFactory_10_50.convertResource(theResource, ADVISOR_10_50); 550 return (IBaseConformance) reencodeFromHl7Org(converted); 551 } 552 553 private Resource reencodeToHl7Org(IBaseResource theInput) { 554 if (theInput == null) { 555 return null; 556 } 557 if (myHl7OrgStructures) { 558 return (Resource) theInput; 559 } 560 return (Resource) myDstu2Hl7OrgContext.newJsonParser().parseResource(encodeAsString(theInput)); 561 } 562 563 private IBaseResource reencodeFromHl7Org(Resource theInput) { 564 if (theInput == null) { 565 return null; 566 } 567 if (myHl7OrgStructures) { 568 return theInput; 569 } 570 return myDstu2Context.newJsonParser().parseResource(encodeAsString(theInput)); 571 } 572 573 private String encodeAsString(IBaseResource theResource) { 574 FhirVersionEnum version = theResource.getStructureFhirVersionEnum(); 575 if (myDstu2Context.getVersion().getVersion().equals(version)) { 576 return myDstu2Context.newJsonParser().encodeResourceToString(theResource); 577 } else if (myDstu2Hl7OrgContext.getVersion().getVersion().equals(version)) { 578 return myDstu2Hl7OrgContext.newJsonParser().encodeResourceToString(theResource); 579 } else { 580 throw new IllegalArgumentException( 581 Msg.code(2777) + "Cannot encode resource with version: %s".formatted(version)); 582 } 583 } 584 } 585 586 private static class Dstu21Strategy implements IStrategy { 587 588 @Override 589 public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) { 590 return (CapabilityStatement) VersionConvertorFactory_14_50.convertResource( 591 (org.hl7.fhir.dstu2016may.model.Resource) theCapabilityStatement, ADVISOR_14_50); 592 } 593 594 @Override 595 public Coding codingToCanonical(IBaseCoding theCoding) { 596 return (org.hl7.fhir.r4.model.Coding) VersionConvertorFactory_14_40.convertType( 597 (org.hl7.fhir.dstu2016may.model.Coding) theCoding, ADVISOR_14_40); 598 } 599 600 @Override 601 public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) { 602 return (org.hl7.fhir.r4.model.CodeableConcept) VersionConvertorFactory_14_40.convertType( 603 (org.hl7.fhir.dstu2016may.model.CodeableConcept) theCodeableConcept, ADVISOR_14_40); 604 } 605 606 @Override 607 public ValueSet valueSetToCanonical(IBaseResource theValueSet) { 608 return (ValueSet) VersionConvertorFactory_14_40.convertResource( 609 (org.hl7.fhir.dstu2016may.model.Resource) theValueSet, ADVISOR_14_40); 610 } 611 612 @Override 613 public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) { 614 return (CodeSystem) VersionConvertorFactory_14_40.convertResource( 615 (org.hl7.fhir.dstu2016may.model.Resource) theCodeSystem, ADVISOR_14_40); 616 } 617 618 @Override 619 public IBaseResource valueSetFromCanonical(ValueSet theValueSet) { 620 return VersionConvertorFactory_14_40.convertResource(theValueSet, ADVISOR_14_40); 621 } 622 623 @Override 624 public IBaseResource codeSystemFromCanonical(CodeSystem theCodeSystem) { 625 return VersionConvertorFactory_14_40.convertResource(theCodeSystem, ADVISOR_14_40); 626 } 627 628 @Override 629 public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) { 630 return (ConceptMap) VersionConvertorFactory_14_40.convertResource( 631 (org.hl7.fhir.dstu2016may.model.Resource) theConceptMap, ADVISOR_14_40); 632 } 633 634 @Override 635 public IBaseResource conceptMapFromCanonical(ConceptMap theConceptMap) { 636 return VersionConvertorFactory_14_40.convertResource(theConceptMap, ADVISOR_14_40); 637 } 638 639 @Override 640 public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) { 641 return (SearchParameter) VersionConvertorFactory_14_50.convertResource( 642 (org.hl7.fhir.dstu2016may.model.Resource) theSearchParameter, ADVISOR_14_50); 643 } 644 645 @Override 646 public IBaseParameters parametersFromCanonical(Parameters theParameters) { 647 return (IBaseParameters) VersionConvertorFactory_14_40.convertResource(theParameters, ADVISOR_14_40); 648 } 649 650 @Override 651 public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) { 652 return (StructureDefinition) VersionConvertorFactory_14_50.convertResource( 653 (org.hl7.fhir.dstu2016may.model.Resource) theResource, ADVISOR_14_50); 654 } 655 656 @Override 657 public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) { 658 return VersionConvertorFactory_14_50.convertResource(theResource, ADVISOR_14_50); 659 } 660 661 @Override 662 public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) { 663 return VersionConvertorFactory_14_50.convertResource(theResource, ADVISOR_14_50); 664 } 665 666 @Override 667 public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) { 668 return VersionConvertorFactory_14_50.convertResource( 669 (org.hl7.fhir.dstu2016may.model.Resource) theResource, ADVISOR_14_50); 670 } 671 672 @Override 673 public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) { 674 return (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_14_50.convertResource( 675 (org.hl7.fhir.dstu2016may.model.Resource) theResource, ADVISOR_14_50); 676 } 677 678 @Override 679 public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) { 680 return (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_14_50.convertResource( 681 (org.hl7.fhir.dstu2016may.model.Resource) theResource, ADVISOR_14_50); 682 } 683 684 @Override 685 public IBaseResource searchParameterFromCanonical(SearchParameter theResource) { 686 return VersionConvertorFactory_14_50.convertResource(theResource, ADVISOR_14_50); 687 } 688 689 @Override 690 public IBaseResource auditEventFromCanonical(AuditEvent theResource) { 691 return VersionConvertorFactory_14_40.convertResource(theResource, ADVISOR_14_40); 692 } 693 694 @Override 695 public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) { 696 return (IBaseConformance) VersionConvertorFactory_14_50.convertResource(theResource, ADVISOR_14_50); 697 } 698 } 699 700 private static class Dstu3Strategy implements IStrategy { 701 702 @Override 703 public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) { 704 return (CapabilityStatement) VersionConvertorFactory_30_50.convertResource( 705 (org.hl7.fhir.dstu3.model.Resource) theCapabilityStatement, ADVISOR_30_50); 706 } 707 708 @Override 709 public Coding codingToCanonical(IBaseCoding theCoding) { 710 return (org.hl7.fhir.r4.model.Coding) VersionConvertorFactory_30_40.convertType( 711 (org.hl7.fhir.dstu3.model.Coding) theCoding, ADVISOR_30_40); 712 } 713 714 @Override 715 public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) { 716 return (org.hl7.fhir.r4.model.CodeableConcept) VersionConvertorFactory_30_40.convertType( 717 (org.hl7.fhir.dstu3.model.CodeableConcept) theCodeableConcept, ADVISOR_30_40); 718 } 719 720 @Override 721 public ValueSet valueSetToCanonical(IBaseResource theValueSet) { 722 return (ValueSet) VersionConvertorFactory_30_40.convertResource( 723 (org.hl7.fhir.dstu3.model.Resource) theValueSet, ADVISOR_30_40); 724 } 725 726 @Override 727 public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) { 728 return (CodeSystem) VersionConvertorFactory_30_40.convertResource( 729 (org.hl7.fhir.dstu3.model.Resource) theCodeSystem, ADVISOR_30_40); 730 } 731 732 @Override 733 public IBaseResource valueSetFromCanonical(ValueSet theValueSet) { 734 return VersionConvertorFactory_30_40.convertResource(theValueSet, ADVISOR_30_40); 735 } 736 737 @Override 738 public IBaseResource codeSystemFromCanonical(CodeSystem theCodeSystem) { 739 return VersionConvertorFactory_30_40.convertResource(theCodeSystem, ADVISOR_30_40); 740 } 741 742 @Override 743 public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) { 744 return (ConceptMap) VersionConvertorFactory_30_40.convertResource( 745 (org.hl7.fhir.dstu3.model.Resource) theConceptMap, ADVISOR_30_40); 746 } 747 748 @Override 749 public IBaseResource conceptMapFromCanonical(ConceptMap theConceptMap) { 750 return VersionConvertorFactory_30_40.convertResource(theConceptMap, ADVISOR_30_40); 751 } 752 753 @Override 754 public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) { 755 return (SearchParameter) VersionConvertorFactory_30_50.convertResource( 756 (org.hl7.fhir.dstu3.model.Resource) theSearchParameter, ADVISOR_30_50); 757 } 758 759 @Override 760 public IBaseParameters parametersFromCanonical(Parameters theParameters) { 761 return (IBaseParameters) VersionConvertorFactory_30_40.convertResource(theParameters, ADVISOR_30_40); 762 } 763 764 @Override 765 public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) { 766 return (StructureDefinition) VersionConvertorFactory_30_50.convertResource( 767 (org.hl7.fhir.dstu3.model.Resource) theResource, ADVISOR_30_50); 768 } 769 770 @Override 771 public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) { 772 return VersionConvertorFactory_30_50.convertResource(theResource, ADVISOR_30_50); 773 } 774 775 @Override 776 public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) { 777 return VersionConvertorFactory_30_50.convertResource(theResource, ADVISOR_30_50); 778 } 779 780 @Override 781 public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) { 782 return VersionConvertorFactory_30_50.convertResource( 783 (org.hl7.fhir.dstu3.model.Resource) theResource, ADVISOR_30_50); 784 } 785 786 @Override 787 public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) { 788 return (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_30_50.convertResource( 789 (org.hl7.fhir.dstu3.model.Resource) theResource, ADVISOR_30_50); 790 } 791 792 @Override 793 public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) { 794 return (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_30_50.convertResource( 795 (org.hl7.fhir.dstu3.model.Resource) theResource, ADVISOR_30_50); 796 } 797 798 @Override 799 public IBaseResource searchParameterFromCanonical(SearchParameter theResource) { 800 return VersionConvertorFactory_30_50.convertResource(theResource, ADVISOR_30_50); 801 } 802 803 @Override 804 public IBaseResource auditEventFromCanonical(AuditEvent theResource) { 805 return VersionConvertorFactory_30_40.convertResource(theResource, ADVISOR_30_40); 806 } 807 808 @Override 809 public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) { 810 return (IBaseConformance) VersionConvertorFactory_30_50.convertResource(theResource, ADVISOR_30_50); 811 } 812 } 813 814 private static class R4Strategy implements IStrategy { 815 @Override 816 public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) { 817 return (CapabilityStatement) VersionConvertorFactory_40_50.convertResource( 818 (org.hl7.fhir.r4.model.Resource) theCapabilityStatement, ADVISOR_40_50); 819 } 820 821 @Override 822 public Coding codingToCanonical(IBaseCoding theCoding) { 823 return (Coding) theCoding; 824 } 825 826 @Override 827 public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) { 828 return (CodeableConcept) theCodeableConcept; 829 } 830 831 @Override 832 public ValueSet valueSetToCanonical(IBaseResource theValueSet) { 833 return (ValueSet) theValueSet; 834 } 835 836 @Override 837 public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) { 838 return (CodeSystem) theCodeSystem; 839 } 840 841 @Override 842 public IBaseResource valueSetFromCanonical(ValueSet theValueSet) { 843 return theValueSet; 844 } 845 846 @Override 847 public IBaseResource codeSystemFromCanonical(CodeSystem theCodeSystem) { 848 return theCodeSystem; 849 } 850 851 @Override 852 public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) { 853 return (ConceptMap) theConceptMap; 854 } 855 856 @Override 857 public IBaseResource conceptMapFromCanonical(ConceptMap theConceptMap) { 858 return theConceptMap; 859 } 860 861 @Override 862 public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) { 863 return (SearchParameter) VersionConvertorFactory_40_50.convertResource( 864 (org.hl7.fhir.r4.model.Resource) theSearchParameter, ADVISOR_40_50); 865 } 866 867 @Override 868 public IBaseParameters parametersFromCanonical(Parameters theParameters) { 869 return theParameters; 870 } 871 872 @Override 873 public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) { 874 return (StructureDefinition) VersionConvertorFactory_40_50.convertResource( 875 (org.hl7.fhir.r4.model.Resource) theResource, ADVISOR_40_50); 876 } 877 878 @Override 879 public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) { 880 return VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50); 881 } 882 883 @Override 884 public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) { 885 return VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50); 886 } 887 888 @Override 889 public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) { 890 return VersionConvertorFactory_40_50.convertResource( 891 (org.hl7.fhir.r4.model.Resource) theResource, ADVISOR_40_50); 892 } 893 894 @Override 895 public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) { 896 return (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_40_50.convertResource( 897 (org.hl7.fhir.r4.model.Resource) theResource, ADVISOR_40_50); 898 } 899 900 @Override 901 public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) { 902 return (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_40_50.convertResource( 903 (org.hl7.fhir.r4.model.Resource) theResource, ADVISOR_40_50); 904 } 905 906 @Override 907 public IBaseResource searchParameterFromCanonical(SearchParameter theResource) { 908 return VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50); 909 } 910 911 @Override 912 public IBaseResource auditEventFromCanonical(AuditEvent theResource) { 913 return theResource; 914 } 915 916 @Override 917 public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) { 918 return (IBaseConformance) VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50); 919 } 920 } 921 922 private static class R4BStrategy implements IStrategy { 923 924 @Override 925 public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) { 926 return (CapabilityStatement) VersionConvertorFactory_43_50.convertResource( 927 (org.hl7.fhir.r4b.model.Resource) theCapabilityStatement, ADVISOR_43_50); 928 } 929 930 @Override 931 public Coding codingToCanonical(IBaseCoding theCoding) { 932 org.hl7.fhir.r5.model.Coding r5coding = (org.hl7.fhir.r5.model.Coding) 933 VersionConvertorFactory_43_50.convertType((org.hl7.fhir.r4b.model.Coding) theCoding, ADVISOR_43_50); 934 return (org.hl7.fhir.r4.model.Coding) VersionConvertorFactory_40_50.convertType(r5coding, ADVISOR_40_50); 935 } 936 937 @Override 938 public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) { 939 org.hl7.fhir.r5.model.CodeableConcept r5coding = 940 (org.hl7.fhir.r5.model.CodeableConcept) VersionConvertorFactory_43_50.convertType( 941 (org.hl7.fhir.r4b.model.CodeableConcept) theCodeableConcept, ADVISOR_43_50); 942 return (org.hl7.fhir.r4.model.CodeableConcept) 943 VersionConvertorFactory_40_50.convertType(r5coding, ADVISOR_40_50); 944 } 945 946 @Override 947 public ValueSet valueSetToCanonical(IBaseResource theValueSet) { 948 org.hl7.fhir.r5.model.ValueSet valueSetR5 = 949 (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_43_50.convertResource( 950 (org.hl7.fhir.r4b.model.Resource) theValueSet, ADVISOR_43_50); 951 return (org.hl7.fhir.r4.model.ValueSet) 952 VersionConvertorFactory_40_50.convertResource(valueSetR5, ADVISOR_40_50); 953 } 954 955 @Override 956 public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) { 957 org.hl7.fhir.r5.model.CodeSystem codeSystemR5 = 958 (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_43_50.convertResource( 959 (org.hl7.fhir.r4b.model.Resource) theCodeSystem, ADVISOR_43_50); 960 return (org.hl7.fhir.r4.model.CodeSystem) 961 VersionConvertorFactory_40_50.convertResource(codeSystemR5, ADVISOR_40_50); 962 } 963 964 @Override 965 public IBaseResource valueSetFromCanonical(ValueSet theValueSet) { 966 org.hl7.fhir.r5.model.ValueSet valueSetR5 = (org.hl7.fhir.r5.model.ValueSet) 967 VersionConvertorFactory_40_50.convertResource(theValueSet, ADVISOR_40_50); 968 return VersionConvertorFactory_43_50.convertResource(valueSetR5, ADVISOR_43_50); 969 } 970 971 @Override 972 public IBaseResource codeSystemFromCanonical(CodeSystem theCodeSystem) { 973 org.hl7.fhir.r5.model.CodeSystem codeSystemR5 = (org.hl7.fhir.r5.model.CodeSystem) 974 VersionConvertorFactory_40_50.convertResource(theCodeSystem, ADVISOR_40_50); 975 return VersionConvertorFactory_43_50.convertResource(codeSystemR5, ADVISOR_43_50); 976 } 977 978 @Override 979 public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) { 980 org.hl7.fhir.r5.model.ConceptMap conceptMapR5 = 981 (org.hl7.fhir.r5.model.ConceptMap) VersionConvertorFactory_43_50.convertResource( 982 (org.hl7.fhir.r4b.model.Resource) theConceptMap, ADVISOR_43_50); 983 return (ConceptMap) VersionConvertorFactory_40_50.convertResource(conceptMapR5, ADVISOR_40_50); 984 } 985 986 @Override 987 public IBaseResource conceptMapFromCanonical(ConceptMap theConceptMap) { 988 org.hl7.fhir.r5.model.ConceptMap conceptMapR5 = (org.hl7.fhir.r5.model.ConceptMap) 989 VersionConvertorFactory_40_50.convertResource(theConceptMap, ADVISOR_40_50); 990 return VersionConvertorFactory_43_50.convertResource(conceptMapR5, ADVISOR_43_50); 991 } 992 993 @Override 994 public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) { 995 return (SearchParameter) VersionConvertorFactory_43_50.convertResource( 996 (org.hl7.fhir.r4b.model.Resource) theSearchParameter, ADVISOR_43_50); 997 } 998 999 @Override 1000 public IBaseParameters parametersFromCanonical(Parameters theParameters) { 1001 org.hl7.fhir.r5.model.Parameters parametersR5 = (org.hl7.fhir.r5.model.Parameters) 1002 VersionConvertorFactory_40_50.convertResource(theParameters, ADVISOR_40_50); 1003 return (IBaseParameters) VersionConvertorFactory_43_50.convertResource(parametersR5, ADVISOR_43_50); 1004 } 1005 1006 @Override 1007 public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) { 1008 return (StructureDefinition) VersionConvertorFactory_43_50.convertResource( 1009 (org.hl7.fhir.r4b.model.Resource) theResource, ADVISOR_43_50); 1010 } 1011 1012 @Override 1013 public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) { 1014 return VersionConvertorFactory_43_50.convertResource(theResource, ADVISOR_43_50); 1015 } 1016 1017 @Override 1018 public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) { 1019 return VersionConvertorFactory_43_50.convertResource(theResource, ADVISOR_43_50); 1020 } 1021 1022 @Override 1023 public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) { 1024 return VersionConvertorFactory_43_50.convertResource( 1025 (org.hl7.fhir.r4b.model.Resource) theResource, ADVISOR_43_50); 1026 } 1027 1028 @Override 1029 public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) { 1030 return (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_43_50.convertResource( 1031 (org.hl7.fhir.r4b.model.Resource) theResource, ADVISOR_43_50); 1032 } 1033 1034 @Override 1035 public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) { 1036 return (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_43_50.convertResource( 1037 (org.hl7.fhir.r4b.model.Resource) theResource, ADVISOR_43_50); 1038 } 1039 1040 @Override 1041 public IBaseResource searchParameterFromCanonical(SearchParameter theResource) { 1042 return VersionConvertorFactory_43_50.convertResource(theResource, ADVISOR_43_50); 1043 } 1044 1045 @Override 1046 public IBaseResource auditEventFromCanonical(AuditEvent theResource) { 1047 org.hl7.fhir.r5.model.AuditEvent r5 = (org.hl7.fhir.r5.model.AuditEvent) 1048 VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50); 1049 return VersionConvertorFactory_43_50.convertResource(r5, ADVISOR_43_50); 1050 } 1051 1052 @Override 1053 public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) { 1054 return (IBaseConformance) VersionConvertorFactory_43_50.convertResource(theResource, ADVISOR_43_50); 1055 } 1056 } 1057 1058 private static class R5Strategy implements IStrategy { 1059 1060 @Override 1061 public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) { 1062 return (CapabilityStatement) theCapabilityStatement; 1063 } 1064 1065 @Override 1066 public Coding codingToCanonical(IBaseCoding theCoding) { 1067 return (org.hl7.fhir.r4.model.Coding) 1068 VersionConvertorFactory_40_50.convertType((org.hl7.fhir.r5.model.Coding) theCoding, ADVISOR_40_50); 1069 } 1070 1071 @Override 1072 public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) { 1073 return (org.hl7.fhir.r4.model.CodeableConcept) VersionConvertorFactory_40_50.convertType( 1074 (org.hl7.fhir.r5.model.CodeableConcept) theCodeableConcept, ADVISOR_40_50); 1075 } 1076 1077 @Override 1078 public ValueSet valueSetToCanonical(IBaseResource theValueSet) { 1079 return (ValueSet) VersionConvertorFactory_40_50.convertResource( 1080 (org.hl7.fhir.r5.model.ValueSet) theValueSet, ADVISOR_40_50); 1081 } 1082 1083 @Override 1084 public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) { 1085 return (CodeSystem) VersionConvertorFactory_40_50.convertResource( 1086 (org.hl7.fhir.r5.model.CodeSystem) theCodeSystem, ADVISOR_40_50); 1087 } 1088 1089 @Override 1090 public IBaseResource valueSetFromCanonical(ValueSet theValueSet) { 1091 return VersionConvertorFactory_40_50.convertResource(theValueSet, ADVISOR_40_50); 1092 } 1093 1094 @Override 1095 public IBaseResource codeSystemFromCanonical(CodeSystem theCodeSystem) { 1096 return VersionConvertorFactory_40_50.convertResource(theCodeSystem, ADVISOR_40_50); 1097 } 1098 1099 @Override 1100 public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) { 1101 return (ConceptMap) VersionConvertorFactory_40_50.convertResource( 1102 (org.hl7.fhir.r5.model.ConceptMap) theConceptMap, ADVISOR_40_50); 1103 } 1104 1105 @Override 1106 public IBaseResource conceptMapFromCanonical(ConceptMap theConceptMap) { 1107 return VersionConvertorFactory_40_50.convertResource(theConceptMap, ADVISOR_40_50); 1108 } 1109 1110 @Override 1111 public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) { 1112 return (SearchParameter) theSearchParameter; 1113 } 1114 1115 @Override 1116 public IBaseParameters parametersFromCanonical(Parameters theParameters) { 1117 return (IBaseParameters) VersionConvertorFactory_40_50.convertResource(theParameters, ADVISOR_40_50); 1118 } 1119 1120 @Override 1121 public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) { 1122 return (StructureDefinition) theResource; 1123 } 1124 1125 @Override 1126 public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) { 1127 return theResource; 1128 } 1129 1130 @Override 1131 public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) { 1132 return theResource; 1133 } 1134 1135 @Override 1136 public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) { 1137 return (org.hl7.fhir.r5.model.Resource) theResource; 1138 } 1139 1140 @Override 1141 public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) { 1142 return (org.hl7.fhir.r5.model.ValueSet) theResource; 1143 } 1144 1145 @Override 1146 public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) { 1147 return (org.hl7.fhir.r5.model.CodeSystem) theResource; 1148 } 1149 1150 @Override 1151 public IBaseResource searchParameterFromCanonical(SearchParameter theResource) { 1152 return theResource; 1153 } 1154 1155 @Override 1156 public IBaseResource auditEventFromCanonical(AuditEvent theResource) { 1157 return VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50); 1158 } 1159 1160 @Override 1161 public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) { 1162 return theResource; 1163 } 1164 } 1165}