Source code

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