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 @SuppressWarnings({"EnhancedSwitchMigration"}) 136 137 /** 138 * Canonical version: R5 139 */ 140 public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) { 141 return myStrategy.capabilityStatementToCanonical(theCapabilityStatement); 142 } 143 144 /** 145 * Canonical version: R5 146 */ 147 public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theCapabilityStatement) { 148 return myStrategy.capabilityStatementFromCanonical(theCapabilityStatement); 149 } 150 151 /** 152 * Canonical version: R4 153 */ 154 public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) { 155 if (theCodeableConcept == null) { 156 return null; 157 } 158 return myStrategy.codeableConceptToCanonical(theCodeableConcept); 159 } 160 161 /** 162 * Canonical version: R4 163 */ 164 public Coding codingToCanonical(IBaseCoding theCodingToValidate) { 165 if (theCodingToValidate == null) { 166 return null; 167 } 168 return myStrategy.codingToCanonical(theCodingToValidate); 169 } 170 171 /** 172 * Canonical version: R4 173 */ 174 public ValueSet valueSetToCanonical(IBaseResource theValueSet) { 175 if (theValueSet == null) { 176 return null; 177 } 178 return myStrategy.valueSetToCanonical(theValueSet); 179 } 180 181 /** 182 * Canonical version: R4 183 */ 184 public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) { 185 return myStrategy.codeSystemToCanonical(theCodeSystem); 186 } 187 188 /** 189 * Canonical version: R4 190 */ 191 public IBaseResource valueSetFromCanonical(ValueSet theValueSet) { 192 return myStrategy.valueSetFromCanonical(theValueSet); 193 } 194 195 /** 196 * Canonical version: R4 197 */ 198 public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) { 199 return myStrategy.conceptMapToCanonical(theConceptMap); 200 } 201 202 /** 203 * Canonical version: R5 204 * <p> 205 * Note that this method will look for any nonstandard resource types specified in 206 * {@literal SearchParameter.base} or {@literal SearchParameter.target} and move them into 207 * extensions with the URLs {@link HapiExtensions#EXTENSION_SEARCHPARAM_CUSTOM_BASE_RESOURCE} 208 * and {@link HapiExtensions#EXTENSION_SEARCHPARAM_CUSTOM_TARGET_RESOURCE} respectively. If any 209 * nonstandard resource types are found, all resource types in the respective list are moved into 210 * the extension (including standard types) and the source list is cleared. 211 */ 212 public <T extends IBaseResource> SearchParameter searchParameterToCanonical(T theSearchParameter) { 213 214 /* 215 * The R4 model allows custom types to be put into SearchParameter.base and 216 * SearchParameter.target because those fields use a simple CodeType. But 217 * in R5 it uses an Enumeration, so it's not actually possible to put custom 218 * resource types into those fields. This means that the version converter fails 219 * with an exception unless we remove those values from those fields before 220 * conversion. However, we don't want to affect the state of the originally 221 * passed in resource since that may affect other things. So, we clone 222 * it first. This is a pain in the butt, but there doesn't seem to be any 223 * better option. 224 */ 225 T input = myContext.newTerser().clone(theSearchParameter); 226 227 List<String> baseExtensionValues = 228 extractNonStandardSearchParameterListAndClearSourceIfAnyArePresent(input, "base"); 229 List<String> targetExtensionValues = 230 extractNonStandardSearchParameterListAndClearSourceIfAnyArePresent(input, "target"); 231 232 SearchParameter retVal = myStrategy.searchParameterToCanonical(input); 233 234 baseExtensionValues.forEach( 235 t -> retVal.addExtension(HapiExtensions.EXTENSION_SEARCHPARAM_CUSTOM_BASE_RESOURCE, new CodeType(t))); 236 targetExtensionValues.forEach( 237 t -> retVal.addExtension(HapiExtensions.EXTENSION_SEARCHPARAM_CUSTOM_TARGET_RESOURCE, new CodeType(t))); 238 return retVal; 239 } 240 241 public IBaseResource searchParameterFromCanonical(SearchParameter theSearchParameter) { 242 return myStrategy.searchParameterFromCanonical(theSearchParameter); 243 } 244 245 public IBaseParameters parametersFromCanonical(Parameters theParameters) { 246 return myStrategy.parametersFromCanonical(theParameters); 247 } 248 249 public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) { 250 StructureDefinition retVal = myStrategy.structureDefinitionToCanonical(theResource); 251 String packageUserData = (String) theResource.getUserData("package"); 252 if (packageUserData != null) { 253 retVal.setUserData("package", packageUserData); 254 retVal.setSourcePackage(new PackageInformation( 255 packageUserData, theResource.getStructureFhirVersionEnum().getFhirVersionString(), new Date())); 256 } 257 return retVal; 258 } 259 260 public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) { 261 return myStrategy.structureDefinitionFromCanonical(theResource); 262 } 263 264 public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) { 265 return myStrategy.valueSetFromValidatorCanonical(theResource); 266 } 267 268 public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) { 269 return myStrategy.resourceToValidatorCanonical(theResource); 270 } 271 272 public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) { 273 return myStrategy.valueSetToValidatorCanonical(theResource); 274 } 275 276 public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) { 277 return myStrategy.codeSystemToValidatorCanonical(theResource); 278 } 279 280 public IBaseResource auditEventFromCanonical(AuditEvent theResource) { 281 return myStrategy.auditEventFromCanonical(theResource); 282 } 283 284 @Nonnull 285 private List<String> extractNonStandardSearchParameterListAndClearSourceIfAnyArePresent( 286 IBaseResource theSearchParameter, String theChildName) { 287 288 BaseRuntimeChildDefinition child = 289 myContext.getResourceDefinition(theSearchParameter).getChildByName(theChildName); 290 List<IBase> baseList = child.getAccessor().getValues(theSearchParameter); 291 292 List<String> baseExtensionValues = baseList.stream() 293 .filter(Objects::nonNull) 294 .filter(t -> t instanceof IPrimitiveType) 295 .map(t -> (IPrimitiveType<?>) t) 296 .map(IPrimitiveType::getValueAsString) 297 .filter(StringUtils::isNotBlank) 298 .collect(Collectors.toList()); 299 if (baseExtensionValues.stream().allMatch(Enumerations.VersionIndependentResourceTypesAll::isValidCode)) { 300 baseExtensionValues.clear(); 301 } else { 302 baseList.clear(); 303 } 304 return baseExtensionValues; 305 } 306 307 public SubscriptionTopic subscriptionTopicToCanonical(IBaseResource theResource) { 308 return SubscriptionTopicCanonicalizer.canonicalizeTopic(myContext, theResource); 309 } 310 311 private interface IStrategy { 312 313 CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement); 314 315 Coding codingToCanonical(IBaseCoding theCoding); 316 317 CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept); 318 319 ValueSet valueSetToCanonical(IBaseResource theValueSet); 320 321 CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem); 322 323 IBaseResource valueSetFromCanonical(ValueSet theValueSet); 324 325 ConceptMap conceptMapToCanonical(IBaseResource theConceptMap); 326 327 SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter); 328 329 IBaseParameters parametersFromCanonical(Parameters theParameters); 330 331 StructureDefinition structureDefinitionToCanonical(IBaseResource theResource); 332 333 IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource); 334 335 IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource); 336 337 org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource); 338 339 org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource); 340 341 org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource); 342 343 IBaseResource searchParameterFromCanonical(SearchParameter theResource); 344 345 IBaseResource auditEventFromCanonical(AuditEvent theResource); 346 347 IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource); 348 } 349 350 private static class Dstu2Strategy implements IStrategy { 351 352 private final FhirContext myDstu2Hl7OrgContext = FhirContext.forDstu2Hl7OrgCached(); 353 354 private final FhirContext myDstu2Context = FhirContext.forDstu2Cached(); 355 private final boolean myHl7OrgStructures; 356 357 public Dstu2Strategy(boolean theHl7OrgStructures) { 358 myHl7OrgStructures = theHl7OrgStructures; 359 } 360 361 @Override 362 public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) { 363 org.hl7.fhir.dstu2.model.Resource reencoded = reencodeToHl7Org(theCapabilityStatement); 364 return (CapabilityStatement) VersionConvertorFactory_10_50.convertResource(reencoded, ADVISOR_10_50); 365 } 366 367 @Override 368 public Coding codingToCanonical(IBaseCoding theCoding) { 369 CodingDt coding = (CodingDt) theCoding; 370 Coding retVal = new Coding(); 371 retVal.setCode(coding.getCode()); 372 retVal.setSystem(coding.getSystem()); 373 retVal.setDisplay(coding.getDisplay()); 374 retVal.setVersion(coding.getVersion()); 375 if (!coding.getUserSelectedElement().isEmpty()) { 376 retVal.setUserSelected(coding.getUserSelected()); 377 } 378 379 return retVal; 380 } 381 382 @Override 383 public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) { 384 CodeableConceptDt codeableConcept = (CodeableConceptDt) theCodeableConcept; 385 386 CodeableConcept retVal = new CodeableConcept(); 387 retVal.setText(codeableConcept.getText()); 388 for (CodingDt next : codeableConcept.getCoding()) { 389 retVal.addCoding(codingToCanonical(next)); 390 } 391 392 return retVal; 393 } 394 395 @Override 396 public ValueSet valueSetToCanonical(IBaseResource theValueSet) { 397 org.hl7.fhir.dstu2.model.Resource reencoded = reencodeToHl7Org(theValueSet); 398 return (ValueSet) VersionConvertorFactory_10_40.convertResource(reencoded, ADVISOR_10_40); 399 } 400 401 @Override 402 public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) { 403 CodeSystem retVal = new CodeSystem(); 404 405 ca.uhn.fhir.model.dstu2.resource.ValueSet input = (ca.uhn.fhir.model.dstu2.resource.ValueSet) theCodeSystem; 406 retVal.setUrl(input.getUrl()); 407 408 for (ca.uhn.fhir.model.dstu2.resource.ValueSet.CodeSystemConcept next : 409 input.getCodeSystem().getConcept()) { 410 translateAndAddConcept(next, retVal.getConcept()); 411 } 412 413 return retVal; 414 } 415 416 private void translateAndAddConcept( 417 ca.uhn.fhir.model.dstu2.resource.ValueSet.CodeSystemConcept theSource, 418 List<CodeSystem.ConceptDefinitionComponent> theTarget) { 419 CodeSystem.ConceptDefinitionComponent targetConcept = new CodeSystem.ConceptDefinitionComponent(); 420 targetConcept.setCode(theSource.getCode()); 421 targetConcept.setDisplay(theSource.getDisplay()); 422 423 for (ca.uhn.fhir.model.dstu2.resource.ValueSet.CodeSystemConceptDesignation next : 424 theSource.getDesignation()) { 425 CodeSystem.ConceptDefinitionDesignationComponent targetDesignation = targetConcept.addDesignation(); 426 targetDesignation.setLanguage(next.getLanguage()); 427 targetDesignation.setValue(next.getValue()); 428 if (next.getUse() != null) { 429 targetDesignation.setUse(codingToCanonical(next.getUse())); 430 } 431 } 432 433 for (ca.uhn.fhir.model.dstu2.resource.ValueSet.CodeSystemConcept nextChild : theSource.getConcept()) { 434 translateAndAddConcept(nextChild, targetConcept.getConcept()); 435 } 436 437 theTarget.add(targetConcept); 438 } 439 440 @Override 441 public IBaseResource valueSetFromCanonical(ValueSet theValueSet) { 442 Resource valueSetDstu2Hl7Org = VersionConvertorFactory_10_40.convertResource(theValueSet, ADVISOR_10_40); 443 return reencodeFromHl7Org(valueSetDstu2Hl7Org); 444 } 445 446 @Override 447 public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) { 448 org.hl7.fhir.dstu2.model.Resource reencoded = reencodeToHl7Org(theConceptMap); 449 return (ConceptMap) VersionConvertorFactory_10_40.convertResource(reencoded, ADVISOR_10_40); 450 } 451 452 @Override 453 public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) { 454 org.hl7.fhir.dstu2.model.SearchParameter reencoded = 455 (org.hl7.fhir.dstu2.model.SearchParameter) reencodeToHl7Org(theSearchParameter); 456 SearchParameter retVal = 457 (SearchParameter) VersionConvertorFactory_10_50.convertResource(reencoded, ADVISOR_10_50); 458 if (isBlank(retVal.getExpression())) { 459 retVal.setExpression(reencoded.getXpath()); 460 } 461 return retVal; 462 } 463 464 @Override 465 public IBaseParameters parametersFromCanonical(Parameters theParameters) { 466 Resource converted = VersionConvertorFactory_10_40.convertResource(theParameters, ADVISOR_10_40); 467 return (IBaseParameters) reencodeFromHl7Org(converted); 468 } 469 470 @Override 471 public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) { 472 org.hl7.fhir.dstu2.model.Resource reencoded = reencodeToHl7Org(theResource); 473 return (StructureDefinition) VersionConvertorFactory_10_50.convertResource(reencoded, ADVISOR_10_50); 474 } 475 476 @Override 477 public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) { 478 Resource converted = VersionConvertorFactory_10_50.convertResource(theResource, ADVISOR_10_50); 479 return reencodeFromHl7Org(converted); 480 } 481 482 @Override 483 public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) { 484 Resource converted = VersionConvertorFactory_10_50.convertResource(theResource, ADVISOR_10_50); 485 return reencodeFromHl7Org(converted); 486 } 487 488 @Override 489 public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) { 490 org.hl7.fhir.dstu2.model.Resource reencoded = reencodeToHl7Org(theResource); 491 return VersionConvertorFactory_10_50.convertResource(reencoded, ADVISOR_10_50); 492 } 493 494 @Override 495 public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) { 496 org.hl7.fhir.dstu2.model.Resource reencoded = reencodeToHl7Org(theResource); 497 return (org.hl7.fhir.r5.model.ValueSet) 498 VersionConvertorFactory_10_50.convertResource(reencoded, ADVISOR_10_50); 499 } 500 501 @Override 502 public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) { 503 org.hl7.fhir.dstu2.model.Resource reencoded = reencodeToHl7Org(theResource); 504 return (org.hl7.fhir.r5.model.CodeSystem) 505 VersionConvertorFactory_10_50.convertResource(reencoded, ADVISOR_10_50); 506 } 507 508 @Override 509 public IBaseResource auditEventFromCanonical(AuditEvent theResource) { 510 Resource hl7Org = VersionConvertorFactory_10_40.convertResource(theResource, ADVISOR_10_40); 511 return reencodeFromHl7Org(hl7Org); 512 } 513 514 @Override 515 public IBaseResource searchParameterFromCanonical(SearchParameter theResource) { 516 Resource resource = VersionConvertorFactory_10_50.convertResource(theResource, ADVISOR_10_50); 517 return reencodeFromHl7Org(resource); 518 } 519 520 @Override 521 public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) { 522 Resource converted = VersionConvertorFactory_10_50.convertResource(theResource, ADVISOR_10_50); 523 return (IBaseConformance) reencodeFromHl7Org(converted); 524 } 525 526 private Resource reencodeToHl7Org(IBaseResource theInput) { 527 if (myHl7OrgStructures) { 528 return (Resource) theInput; 529 } 530 return (Resource) myDstu2Hl7OrgContext 531 .newJsonParser() 532 .parseResource(myDstu2Context.newJsonParser().encodeResourceToString(theInput)); 533 } 534 535 private IBaseResource reencodeFromHl7Org(Resource theInput) { 536 if (myHl7OrgStructures) { 537 return theInput; 538 } 539 return myDstu2Context 540 .newJsonParser() 541 .parseResource(myDstu2Hl7OrgContext.newJsonParser().encodeResourceToString(theInput)); 542 } 543 } 544 545 private static class Dstu21Strategy implements IStrategy { 546 547 @Override 548 public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) { 549 return (CapabilityStatement) VersionConvertorFactory_14_50.convertResource( 550 (org.hl7.fhir.dstu2016may.model.Resource) theCapabilityStatement, ADVISOR_14_50); 551 } 552 553 @Override 554 public Coding codingToCanonical(IBaseCoding theCoding) { 555 return (org.hl7.fhir.r4.model.Coding) VersionConvertorFactory_14_40.convertType( 556 (org.hl7.fhir.dstu2016may.model.Coding) theCoding, ADVISOR_14_40); 557 } 558 559 @Override 560 public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) { 561 return (org.hl7.fhir.r4.model.CodeableConcept) VersionConvertorFactory_14_40.convertType( 562 (org.hl7.fhir.dstu2016may.model.CodeableConcept) theCodeableConcept, ADVISOR_14_40); 563 } 564 565 @Override 566 public ValueSet valueSetToCanonical(IBaseResource theValueSet) { 567 return (ValueSet) VersionConvertorFactory_14_40.convertResource( 568 (org.hl7.fhir.dstu2016may.model.Resource) theValueSet, ADVISOR_14_40); 569 } 570 571 @Override 572 public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) { 573 return (CodeSystem) VersionConvertorFactory_14_40.convertResource( 574 (org.hl7.fhir.dstu2016may.model.Resource) theCodeSystem, ADVISOR_14_40); 575 } 576 577 @Override 578 public IBaseResource valueSetFromCanonical(ValueSet theValueSet) { 579 return VersionConvertorFactory_14_40.convertResource(theValueSet, ADVISOR_14_40); 580 } 581 582 @Override 583 public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) { 584 return (ConceptMap) VersionConvertorFactory_14_40.convertResource( 585 (org.hl7.fhir.dstu2016may.model.Resource) theConceptMap, ADVISOR_14_40); 586 } 587 588 @Override 589 public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) { 590 return (SearchParameter) VersionConvertorFactory_14_50.convertResource( 591 (org.hl7.fhir.dstu2016may.model.Resource) theSearchParameter, ADVISOR_14_50); 592 } 593 594 @Override 595 public IBaseParameters parametersFromCanonical(Parameters theParameters) { 596 return (IBaseParameters) VersionConvertorFactory_14_40.convertResource(theParameters, ADVISOR_14_40); 597 } 598 599 @Override 600 public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) { 601 return (StructureDefinition) VersionConvertorFactory_14_50.convertResource( 602 (org.hl7.fhir.dstu2016may.model.Resource) theResource, ADVISOR_14_50); 603 } 604 605 @Override 606 public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) { 607 return VersionConvertorFactory_14_50.convertResource(theResource, ADVISOR_14_50); 608 } 609 610 @Override 611 public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) { 612 return VersionConvertorFactory_14_50.convertResource(theResource, ADVISOR_14_50); 613 } 614 615 @Override 616 public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) { 617 return VersionConvertorFactory_14_50.convertResource( 618 (org.hl7.fhir.dstu2016may.model.Resource) theResource, ADVISOR_14_50); 619 } 620 621 @Override 622 public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) { 623 return (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_14_50.convertResource( 624 (org.hl7.fhir.dstu2016may.model.Resource) theResource, ADVISOR_14_50); 625 } 626 627 @Override 628 public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) { 629 return (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_14_50.convertResource( 630 (org.hl7.fhir.dstu2016may.model.Resource) theResource, ADVISOR_14_50); 631 } 632 633 @Override 634 public IBaseResource searchParameterFromCanonical(SearchParameter theResource) { 635 return VersionConvertorFactory_14_50.convertResource(theResource, ADVISOR_14_50); 636 } 637 638 @Override 639 public IBaseResource auditEventFromCanonical(AuditEvent theResource) { 640 return VersionConvertorFactory_14_40.convertResource(theResource, ADVISOR_14_40); 641 } 642 643 @Override 644 public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) { 645 return (IBaseConformance) VersionConvertorFactory_14_50.convertResource(theResource, ADVISOR_14_50); 646 } 647 } 648 649 private static class Dstu3Strategy implements IStrategy { 650 651 @Override 652 public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) { 653 return (CapabilityStatement) VersionConvertorFactory_30_50.convertResource( 654 (org.hl7.fhir.dstu3.model.Resource) theCapabilityStatement, ADVISOR_30_50); 655 } 656 657 @Override 658 public Coding codingToCanonical(IBaseCoding theCoding) { 659 return (org.hl7.fhir.r4.model.Coding) VersionConvertorFactory_30_40.convertType( 660 (org.hl7.fhir.dstu3.model.Coding) theCoding, ADVISOR_30_40); 661 } 662 663 @Override 664 public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) { 665 return (org.hl7.fhir.r4.model.CodeableConcept) VersionConvertorFactory_30_40.convertType( 666 (org.hl7.fhir.dstu3.model.CodeableConcept) theCodeableConcept, ADVISOR_30_40); 667 } 668 669 @Override 670 public ValueSet valueSetToCanonical(IBaseResource theValueSet) { 671 return (ValueSet) VersionConvertorFactory_30_40.convertResource( 672 (org.hl7.fhir.dstu3.model.Resource) theValueSet, ADVISOR_30_40); 673 } 674 675 @Override 676 public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) { 677 return (CodeSystem) VersionConvertorFactory_30_40.convertResource( 678 (org.hl7.fhir.dstu3.model.Resource) theCodeSystem, ADVISOR_30_40); 679 } 680 681 @Override 682 public IBaseResource valueSetFromCanonical(ValueSet theValueSet) { 683 return VersionConvertorFactory_30_40.convertResource(theValueSet, ADVISOR_30_40); 684 } 685 686 @Override 687 public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) { 688 return (ConceptMap) VersionConvertorFactory_30_40.convertResource( 689 (org.hl7.fhir.dstu3.model.Resource) theConceptMap, ADVISOR_30_40); 690 } 691 692 @Override 693 public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) { 694 return (SearchParameter) VersionConvertorFactory_30_50.convertResource( 695 (org.hl7.fhir.dstu3.model.Resource) theSearchParameter, ADVISOR_30_50); 696 } 697 698 @Override 699 public IBaseParameters parametersFromCanonical(Parameters theParameters) { 700 return (IBaseParameters) VersionConvertorFactory_30_40.convertResource(theParameters, ADVISOR_30_40); 701 } 702 703 @Override 704 public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) { 705 return (StructureDefinition) VersionConvertorFactory_30_50.convertResource( 706 (org.hl7.fhir.dstu3.model.Resource) theResource, ADVISOR_30_50); 707 } 708 709 @Override 710 public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) { 711 return VersionConvertorFactory_30_50.convertResource(theResource, ADVISOR_30_50); 712 } 713 714 @Override 715 public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) { 716 return VersionConvertorFactory_30_50.convertResource(theResource, ADVISOR_30_50); 717 } 718 719 @Override 720 public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) { 721 return VersionConvertorFactory_30_50.convertResource( 722 (org.hl7.fhir.dstu3.model.Resource) theResource, ADVISOR_30_50); 723 } 724 725 @Override 726 public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) { 727 return (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_30_50.convertResource( 728 (org.hl7.fhir.dstu3.model.Resource) theResource, ADVISOR_30_50); 729 } 730 731 @Override 732 public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) { 733 return (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_30_50.convertResource( 734 (org.hl7.fhir.dstu3.model.Resource) theResource, ADVISOR_30_50); 735 } 736 737 @Override 738 public IBaseResource searchParameterFromCanonical(SearchParameter theResource) { 739 return VersionConvertorFactory_30_50.convertResource(theResource, ADVISOR_30_50); 740 } 741 742 @Override 743 public IBaseResource auditEventFromCanonical(AuditEvent theResource) { 744 return VersionConvertorFactory_30_40.convertResource(theResource, ADVISOR_30_40); 745 } 746 747 @Override 748 public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) { 749 return (IBaseConformance) VersionConvertorFactory_30_50.convertResource(theResource, ADVISOR_30_50); 750 } 751 } 752 753 private static class R4Strategy implements IStrategy { 754 @Override 755 public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) { 756 return (CapabilityStatement) VersionConvertorFactory_40_50.convertResource( 757 (org.hl7.fhir.r4.model.Resource) theCapabilityStatement, ADVISOR_40_50); 758 } 759 760 @Override 761 public Coding codingToCanonical(IBaseCoding theCoding) { 762 return (Coding) theCoding; 763 } 764 765 @Override 766 public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) { 767 return (CodeableConcept) theCodeableConcept; 768 } 769 770 @Override 771 public ValueSet valueSetToCanonical(IBaseResource theValueSet) { 772 return (ValueSet) theValueSet; 773 } 774 775 @Override 776 public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) { 777 return (CodeSystem) theCodeSystem; 778 } 779 780 @Override 781 public IBaseResource valueSetFromCanonical(ValueSet theValueSet) { 782 return theValueSet; 783 } 784 785 @Override 786 public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) { 787 return (ConceptMap) theConceptMap; 788 } 789 790 @Override 791 public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) { 792 return (SearchParameter) VersionConvertorFactory_40_50.convertResource( 793 (org.hl7.fhir.r4.model.Resource) theSearchParameter, ADVISOR_40_50); 794 } 795 796 @Override 797 public IBaseParameters parametersFromCanonical(Parameters theParameters) { 798 return theParameters; 799 } 800 801 @Override 802 public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) { 803 return (StructureDefinition) VersionConvertorFactory_40_50.convertResource( 804 (org.hl7.fhir.r4.model.Resource) theResource, ADVISOR_40_50); 805 } 806 807 @Override 808 public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) { 809 return VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50); 810 } 811 812 @Override 813 public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) { 814 return VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50); 815 } 816 817 @Override 818 public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) { 819 return VersionConvertorFactory_40_50.convertResource( 820 (org.hl7.fhir.r4.model.Resource) theResource, ADVISOR_40_50); 821 } 822 823 @Override 824 public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) { 825 return (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_40_50.convertResource( 826 (org.hl7.fhir.r4.model.Resource) theResource, ADVISOR_40_50); 827 } 828 829 @Override 830 public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) { 831 return (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_40_50.convertResource( 832 (org.hl7.fhir.r4.model.Resource) theResource, ADVISOR_40_50); 833 } 834 835 @Override 836 public IBaseResource searchParameterFromCanonical(SearchParameter theResource) { 837 return VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50); 838 } 839 840 @Override 841 public IBaseResource auditEventFromCanonical(AuditEvent theResource) { 842 return theResource; 843 } 844 845 @Override 846 public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) { 847 return (IBaseConformance) VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50); 848 } 849 } 850 851 private static class R4BStrategy implements IStrategy { 852 853 @Override 854 public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) { 855 return (CapabilityStatement) VersionConvertorFactory_43_50.convertResource( 856 (org.hl7.fhir.r4b.model.Resource) theCapabilityStatement, ADVISOR_43_50); 857 } 858 859 @Override 860 public Coding codingToCanonical(IBaseCoding theCoding) { 861 org.hl7.fhir.r5.model.Coding r5coding = (org.hl7.fhir.r5.model.Coding) 862 VersionConvertorFactory_43_50.convertType((org.hl7.fhir.r4b.model.Coding) theCoding, ADVISOR_43_50); 863 return (org.hl7.fhir.r4.model.Coding) VersionConvertorFactory_40_50.convertType(r5coding, ADVISOR_40_50); 864 } 865 866 @Override 867 public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) { 868 org.hl7.fhir.r5.model.CodeableConcept r5coding = 869 (org.hl7.fhir.r5.model.CodeableConcept) VersionConvertorFactory_43_50.convertType( 870 (org.hl7.fhir.r4b.model.CodeableConcept) theCodeableConcept, ADVISOR_43_50); 871 return (org.hl7.fhir.r4.model.CodeableConcept) 872 VersionConvertorFactory_40_50.convertType(r5coding, ADVISOR_40_50); 873 } 874 875 @Override 876 public ValueSet valueSetToCanonical(IBaseResource theValueSet) { 877 org.hl7.fhir.r5.model.ValueSet valueSetR5 = 878 (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_43_50.convertResource( 879 (org.hl7.fhir.r4b.model.Resource) theValueSet, ADVISOR_43_50); 880 return (org.hl7.fhir.r4.model.ValueSet) 881 VersionConvertorFactory_40_50.convertResource(valueSetR5, ADVISOR_40_50); 882 } 883 884 @Override 885 public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) { 886 org.hl7.fhir.r5.model.CodeSystem codeSystemR5 = 887 (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_43_50.convertResource( 888 (org.hl7.fhir.r4b.model.Resource) theCodeSystem, ADVISOR_43_50); 889 return (org.hl7.fhir.r4.model.CodeSystem) 890 VersionConvertorFactory_40_50.convertResource(codeSystemR5, ADVISOR_40_50); 891 } 892 893 @Override 894 public IBaseResource valueSetFromCanonical(ValueSet theValueSet) { 895 org.hl7.fhir.r5.model.ValueSet valueSetR5 = (org.hl7.fhir.r5.model.ValueSet) 896 VersionConvertorFactory_40_50.convertResource(theValueSet, ADVISOR_40_50); 897 return VersionConvertorFactory_43_50.convertResource(valueSetR5, ADVISOR_43_50); 898 } 899 900 @Override 901 public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) { 902 org.hl7.fhir.r5.model.ConceptMap conceptMapR5 = 903 (org.hl7.fhir.r5.model.ConceptMap) VersionConvertorFactory_43_50.convertResource( 904 (org.hl7.fhir.r4b.model.Resource) theConceptMap, ADVISOR_43_50); 905 return (ConceptMap) VersionConvertorFactory_40_50.convertResource(conceptMapR5, ADVISOR_40_50); 906 } 907 908 @Override 909 public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) { 910 return (SearchParameter) VersionConvertorFactory_43_50.convertResource( 911 (org.hl7.fhir.r4b.model.Resource) theSearchParameter, ADVISOR_43_50); 912 } 913 914 @Override 915 public IBaseParameters parametersFromCanonical(Parameters theParameters) { 916 org.hl7.fhir.r5.model.Parameters parametersR5 = (org.hl7.fhir.r5.model.Parameters) 917 VersionConvertorFactory_40_50.convertResource(theParameters, ADVISOR_40_50); 918 return (IBaseParameters) VersionConvertorFactory_43_50.convertResource(parametersR5, ADVISOR_43_50); 919 } 920 921 @Override 922 public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) { 923 return (StructureDefinition) VersionConvertorFactory_43_50.convertResource( 924 (org.hl7.fhir.r4b.model.Resource) theResource, ADVISOR_43_50); 925 } 926 927 @Override 928 public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) { 929 return VersionConvertorFactory_43_50.convertResource(theResource, ADVISOR_43_50); 930 } 931 932 @Override 933 public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) { 934 return VersionConvertorFactory_43_50.convertResource(theResource, ADVISOR_43_50); 935 } 936 937 @Override 938 public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) { 939 return VersionConvertorFactory_43_50.convertResource( 940 (org.hl7.fhir.r4b.model.Resource) theResource, ADVISOR_43_50); 941 } 942 943 @Override 944 public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) { 945 return (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_43_50.convertResource( 946 (org.hl7.fhir.r4b.model.Resource) theResource, ADVISOR_43_50); 947 } 948 949 @Override 950 public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) { 951 return (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_43_50.convertResource( 952 (org.hl7.fhir.r4b.model.Resource) theResource, ADVISOR_43_50); 953 } 954 955 @Override 956 public IBaseResource searchParameterFromCanonical(SearchParameter theResource) { 957 return VersionConvertorFactory_43_50.convertResource(theResource, ADVISOR_43_50); 958 } 959 960 @Override 961 public IBaseResource auditEventFromCanonical(AuditEvent theResource) { 962 org.hl7.fhir.r5.model.AuditEvent r5 = (org.hl7.fhir.r5.model.AuditEvent) 963 VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50); 964 return VersionConvertorFactory_43_50.convertResource(r5, ADVISOR_43_50); 965 } 966 967 @Override 968 public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) { 969 return (IBaseConformance) VersionConvertorFactory_43_50.convertResource(theResource, ADVISOR_43_50); 970 } 971 } 972 973 private static class R5Strategy implements IStrategy { 974 975 @Override 976 public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) { 977 return (CapabilityStatement) theCapabilityStatement; 978 } 979 980 @Override 981 public Coding codingToCanonical(IBaseCoding theCoding) { 982 return (org.hl7.fhir.r4.model.Coding) 983 VersionConvertorFactory_40_50.convertType((org.hl7.fhir.r5.model.Coding) theCoding, ADVISOR_40_50); 984 } 985 986 @Override 987 public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) { 988 return (org.hl7.fhir.r4.model.CodeableConcept) VersionConvertorFactory_40_50.convertType( 989 (org.hl7.fhir.r5.model.CodeableConcept) theCodeableConcept, ADVISOR_40_50); 990 } 991 992 @Override 993 public ValueSet valueSetToCanonical(IBaseResource theValueSet) { 994 return (ValueSet) VersionConvertorFactory_40_50.convertResource( 995 (org.hl7.fhir.r5.model.ValueSet) theValueSet, ADVISOR_40_50); 996 } 997 998 @Override 999 public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) { 1000 return (CodeSystem) VersionConvertorFactory_40_50.convertResource( 1001 (org.hl7.fhir.r5.model.CodeSystem) theCodeSystem, ADVISOR_40_50); 1002 } 1003 1004 @Override 1005 public IBaseResource valueSetFromCanonical(ValueSet theValueSet) { 1006 return VersionConvertorFactory_40_50.convertResource(theValueSet, ADVISOR_40_50); 1007 } 1008 1009 @Override 1010 public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) { 1011 return (ConceptMap) VersionConvertorFactory_40_50.convertResource( 1012 (org.hl7.fhir.r5.model.ConceptMap) theConceptMap, ADVISOR_40_50); 1013 } 1014 1015 @Override 1016 public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) { 1017 return (SearchParameter) theSearchParameter; 1018 } 1019 1020 @Override 1021 public IBaseParameters parametersFromCanonical(Parameters theParameters) { 1022 return (IBaseParameters) VersionConvertorFactory_40_50.convertResource(theParameters, ADVISOR_40_50); 1023 } 1024 1025 @Override 1026 public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) { 1027 return (StructureDefinition) theResource; 1028 } 1029 1030 @Override 1031 public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) { 1032 return theResource; 1033 } 1034 1035 @Override 1036 public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) { 1037 return theResource; 1038 } 1039 1040 @Override 1041 public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) { 1042 return (org.hl7.fhir.r5.model.Resource) theResource; 1043 } 1044 1045 @Override 1046 public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) { 1047 return (org.hl7.fhir.r5.model.ValueSet) theResource; 1048 } 1049 1050 @Override 1051 public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) { 1052 return (org.hl7.fhir.r5.model.CodeSystem) theResource; 1053 } 1054 1055 @Override 1056 public IBaseResource searchParameterFromCanonical(SearchParameter theResource) { 1057 return theResource; 1058 } 1059 1060 @Override 1061 public IBaseResource auditEventFromCanonical(AuditEvent theResource) { 1062 return VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50); 1063 } 1064 1065 @Override 1066 public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) { 1067 return theResource; 1068 } 1069 } 1070}