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(
570                                                Msg.code(2777) + "Cannot encode resource with version: %s".formatted(version));
571                        }
572                }
573        }
574
575        private static class Dstu21Strategy implements IStrategy {
576
577                @Override
578                public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) {
579                        return (CapabilityStatement) VersionConvertorFactory_14_50.convertResource(
580                                        (org.hl7.fhir.dstu2016may.model.Resource) theCapabilityStatement, ADVISOR_14_50);
581                }
582
583                @Override
584                public Coding codingToCanonical(IBaseCoding theCoding) {
585                        return (org.hl7.fhir.r4.model.Coding) VersionConvertorFactory_14_40.convertType(
586                                        (org.hl7.fhir.dstu2016may.model.Coding) theCoding, ADVISOR_14_40);
587                }
588
589                @Override
590                public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) {
591                        return (org.hl7.fhir.r4.model.CodeableConcept) VersionConvertorFactory_14_40.convertType(
592                                        (org.hl7.fhir.dstu2016may.model.CodeableConcept) theCodeableConcept, ADVISOR_14_40);
593                }
594
595                @Override
596                public ValueSet valueSetToCanonical(IBaseResource theValueSet) {
597                        return (ValueSet) VersionConvertorFactory_14_40.convertResource(
598                                        (org.hl7.fhir.dstu2016may.model.Resource) theValueSet, ADVISOR_14_40);
599                }
600
601                @Override
602                public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) {
603                        return (CodeSystem) VersionConvertorFactory_14_40.convertResource(
604                                        (org.hl7.fhir.dstu2016may.model.Resource) theCodeSystem, ADVISOR_14_40);
605                }
606
607                @Override
608                public IBaseResource valueSetFromCanonical(ValueSet theValueSet) {
609                        return VersionConvertorFactory_14_40.convertResource(theValueSet, ADVISOR_14_40);
610                }
611
612                @Override
613                public IBaseResource codeSystemFromCanonical(CodeSystem theCodeSystem) {
614                        return VersionConvertorFactory_14_40.convertResource(theCodeSystem, ADVISOR_14_40);
615                }
616
617                @Override
618                public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) {
619                        return (ConceptMap) VersionConvertorFactory_14_40.convertResource(
620                                        (org.hl7.fhir.dstu2016may.model.Resource) theConceptMap, ADVISOR_14_40);
621                }
622
623                @Override
624                public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) {
625                        return (SearchParameter) VersionConvertorFactory_14_50.convertResource(
626                                        (org.hl7.fhir.dstu2016may.model.Resource) theSearchParameter, ADVISOR_14_50);
627                }
628
629                @Override
630                public IBaseParameters parametersFromCanonical(Parameters theParameters) {
631                        return (IBaseParameters) VersionConvertorFactory_14_40.convertResource(theParameters, ADVISOR_14_40);
632                }
633
634                @Override
635                public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) {
636                        return (StructureDefinition) VersionConvertorFactory_14_50.convertResource(
637                                        (org.hl7.fhir.dstu2016may.model.Resource) theResource, ADVISOR_14_50);
638                }
639
640                @Override
641                public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) {
642                        return VersionConvertorFactory_14_50.convertResource(theResource, ADVISOR_14_50);
643                }
644
645                @Override
646                public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) {
647                        return VersionConvertorFactory_14_50.convertResource(theResource, ADVISOR_14_50);
648                }
649
650                @Override
651                public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) {
652                        return VersionConvertorFactory_14_50.convertResource(
653                                        (org.hl7.fhir.dstu2016may.model.Resource) theResource, ADVISOR_14_50);
654                }
655
656                @Override
657                public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) {
658                        return (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_14_50.convertResource(
659                                        (org.hl7.fhir.dstu2016may.model.Resource) theResource, ADVISOR_14_50);
660                }
661
662                @Override
663                public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) {
664                        return (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_14_50.convertResource(
665                                        (org.hl7.fhir.dstu2016may.model.Resource) theResource, ADVISOR_14_50);
666                }
667
668                @Override
669                public IBaseResource searchParameterFromCanonical(SearchParameter theResource) {
670                        return VersionConvertorFactory_14_50.convertResource(theResource, ADVISOR_14_50);
671                }
672
673                @Override
674                public IBaseResource auditEventFromCanonical(AuditEvent theResource) {
675                        return VersionConvertorFactory_14_40.convertResource(theResource, ADVISOR_14_40);
676                }
677
678                @Override
679                public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) {
680                        return (IBaseConformance) VersionConvertorFactory_14_50.convertResource(theResource, ADVISOR_14_50);
681                }
682        }
683
684        private static class Dstu3Strategy implements IStrategy {
685
686                @Override
687                public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) {
688                        return (CapabilityStatement) VersionConvertorFactory_30_50.convertResource(
689                                        (org.hl7.fhir.dstu3.model.Resource) theCapabilityStatement, ADVISOR_30_50);
690                }
691
692                @Override
693                public Coding codingToCanonical(IBaseCoding theCoding) {
694                        return (org.hl7.fhir.r4.model.Coding) VersionConvertorFactory_30_40.convertType(
695                                        (org.hl7.fhir.dstu3.model.Coding) theCoding, ADVISOR_30_40);
696                }
697
698                @Override
699                public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) {
700                        return (org.hl7.fhir.r4.model.CodeableConcept) VersionConvertorFactory_30_40.convertType(
701                                        (org.hl7.fhir.dstu3.model.CodeableConcept) theCodeableConcept, ADVISOR_30_40);
702                }
703
704                @Override
705                public ValueSet valueSetToCanonical(IBaseResource theValueSet) {
706                        return (ValueSet) VersionConvertorFactory_30_40.convertResource(
707                                        (org.hl7.fhir.dstu3.model.Resource) theValueSet, ADVISOR_30_40);
708                }
709
710                @Override
711                public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) {
712                        return (CodeSystem) VersionConvertorFactory_30_40.convertResource(
713                                        (org.hl7.fhir.dstu3.model.Resource) theCodeSystem, ADVISOR_30_40);
714                }
715
716                @Override
717                public IBaseResource valueSetFromCanonical(ValueSet theValueSet) {
718                        return VersionConvertorFactory_30_40.convertResource(theValueSet, ADVISOR_30_40);
719                }
720
721                @Override
722                public IBaseResource codeSystemFromCanonical(CodeSystem theCodeSystem) {
723                        return VersionConvertorFactory_30_40.convertResource(theCodeSystem, ADVISOR_30_40);
724                }
725
726                @Override
727                public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) {
728                        return (ConceptMap) VersionConvertorFactory_30_40.convertResource(
729                                        (org.hl7.fhir.dstu3.model.Resource) theConceptMap, ADVISOR_30_40);
730                }
731
732                @Override
733                public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) {
734                        return (SearchParameter) VersionConvertorFactory_30_50.convertResource(
735                                        (org.hl7.fhir.dstu3.model.Resource) theSearchParameter, ADVISOR_30_50);
736                }
737
738                @Override
739                public IBaseParameters parametersFromCanonical(Parameters theParameters) {
740                        return (IBaseParameters) VersionConvertorFactory_30_40.convertResource(theParameters, ADVISOR_30_40);
741                }
742
743                @Override
744                public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) {
745                        return (StructureDefinition) VersionConvertorFactory_30_50.convertResource(
746                                        (org.hl7.fhir.dstu3.model.Resource) theResource, ADVISOR_30_50);
747                }
748
749                @Override
750                public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) {
751                        return VersionConvertorFactory_30_50.convertResource(theResource, ADVISOR_30_50);
752                }
753
754                @Override
755                public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) {
756                        return VersionConvertorFactory_30_50.convertResource(theResource, ADVISOR_30_50);
757                }
758
759                @Override
760                public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) {
761                        return VersionConvertorFactory_30_50.convertResource(
762                                        (org.hl7.fhir.dstu3.model.Resource) theResource, ADVISOR_30_50);
763                }
764
765                @Override
766                public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) {
767                        return (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_30_50.convertResource(
768                                        (org.hl7.fhir.dstu3.model.Resource) theResource, ADVISOR_30_50);
769                }
770
771                @Override
772                public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) {
773                        return (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_30_50.convertResource(
774                                        (org.hl7.fhir.dstu3.model.Resource) theResource, ADVISOR_30_50);
775                }
776
777                @Override
778                public IBaseResource searchParameterFromCanonical(SearchParameter theResource) {
779                        return VersionConvertorFactory_30_50.convertResource(theResource, ADVISOR_30_50);
780                }
781
782                @Override
783                public IBaseResource auditEventFromCanonical(AuditEvent theResource) {
784                        return VersionConvertorFactory_30_40.convertResource(theResource, ADVISOR_30_40);
785                }
786
787                @Override
788                public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) {
789                        return (IBaseConformance) VersionConvertorFactory_30_50.convertResource(theResource, ADVISOR_30_50);
790                }
791        }
792
793        private static class R4Strategy implements IStrategy {
794                @Override
795                public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) {
796                        return (CapabilityStatement) VersionConvertorFactory_40_50.convertResource(
797                                        (org.hl7.fhir.r4.model.Resource) theCapabilityStatement, ADVISOR_40_50);
798                }
799
800                @Override
801                public Coding codingToCanonical(IBaseCoding theCoding) {
802                        return (Coding) theCoding;
803                }
804
805                @Override
806                public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) {
807                        return (CodeableConcept) theCodeableConcept;
808                }
809
810                @Override
811                public ValueSet valueSetToCanonical(IBaseResource theValueSet) {
812                        return (ValueSet) theValueSet;
813                }
814
815                @Override
816                public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) {
817                        return (CodeSystem) theCodeSystem;
818                }
819
820                @Override
821                public IBaseResource valueSetFromCanonical(ValueSet theValueSet) {
822                        return theValueSet;
823                }
824
825                @Override
826                public IBaseResource codeSystemFromCanonical(CodeSystem theCodeSystem) {
827                        return theCodeSystem;
828                }
829
830                @Override
831                public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) {
832                        return (ConceptMap) theConceptMap;
833                }
834
835                @Override
836                public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) {
837                        return (SearchParameter) VersionConvertorFactory_40_50.convertResource(
838                                        (org.hl7.fhir.r4.model.Resource) theSearchParameter, ADVISOR_40_50);
839                }
840
841                @Override
842                public IBaseParameters parametersFromCanonical(Parameters theParameters) {
843                        return theParameters;
844                }
845
846                @Override
847                public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) {
848                        return (StructureDefinition) VersionConvertorFactory_40_50.convertResource(
849                                        (org.hl7.fhir.r4.model.Resource) theResource, ADVISOR_40_50);
850                }
851
852                @Override
853                public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) {
854                        return VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50);
855                }
856
857                @Override
858                public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) {
859                        return VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50);
860                }
861
862                @Override
863                public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) {
864                        return VersionConvertorFactory_40_50.convertResource(
865                                        (org.hl7.fhir.r4.model.Resource) theResource, ADVISOR_40_50);
866                }
867
868                @Override
869                public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) {
870                        return (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_40_50.convertResource(
871                                        (org.hl7.fhir.r4.model.Resource) theResource, ADVISOR_40_50);
872                }
873
874                @Override
875                public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) {
876                        return (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_40_50.convertResource(
877                                        (org.hl7.fhir.r4.model.Resource) theResource, ADVISOR_40_50);
878                }
879
880                @Override
881                public IBaseResource searchParameterFromCanonical(SearchParameter theResource) {
882                        return VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50);
883                }
884
885                @Override
886                public IBaseResource auditEventFromCanonical(AuditEvent theResource) {
887                        return theResource;
888                }
889
890                @Override
891                public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) {
892                        return (IBaseConformance) VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50);
893                }
894        }
895
896        private static class R4BStrategy implements IStrategy {
897
898                @Override
899                public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) {
900                        return (CapabilityStatement) VersionConvertorFactory_43_50.convertResource(
901                                        (org.hl7.fhir.r4b.model.Resource) theCapabilityStatement, ADVISOR_43_50);
902                }
903
904                @Override
905                public Coding codingToCanonical(IBaseCoding theCoding) {
906                        org.hl7.fhir.r5.model.Coding r5coding = (org.hl7.fhir.r5.model.Coding)
907                                        VersionConvertorFactory_43_50.convertType((org.hl7.fhir.r4b.model.Coding) theCoding, ADVISOR_43_50);
908                        return (org.hl7.fhir.r4.model.Coding) VersionConvertorFactory_40_50.convertType(r5coding, ADVISOR_40_50);
909                }
910
911                @Override
912                public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) {
913                        org.hl7.fhir.r5.model.CodeableConcept r5coding =
914                                        (org.hl7.fhir.r5.model.CodeableConcept) VersionConvertorFactory_43_50.convertType(
915                                                        (org.hl7.fhir.r4b.model.CodeableConcept) theCodeableConcept, ADVISOR_43_50);
916                        return (org.hl7.fhir.r4.model.CodeableConcept)
917                                        VersionConvertorFactory_40_50.convertType(r5coding, ADVISOR_40_50);
918                }
919
920                @Override
921                public ValueSet valueSetToCanonical(IBaseResource theValueSet) {
922                        org.hl7.fhir.r5.model.ValueSet valueSetR5 =
923                                        (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_43_50.convertResource(
924                                                        (org.hl7.fhir.r4b.model.Resource) theValueSet, ADVISOR_43_50);
925                        return (org.hl7.fhir.r4.model.ValueSet)
926                                        VersionConvertorFactory_40_50.convertResource(valueSetR5, ADVISOR_40_50);
927                }
928
929                @Override
930                public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) {
931                        org.hl7.fhir.r5.model.CodeSystem codeSystemR5 =
932                                        (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_43_50.convertResource(
933                                                        (org.hl7.fhir.r4b.model.Resource) theCodeSystem, ADVISOR_43_50);
934                        return (org.hl7.fhir.r4.model.CodeSystem)
935                                        VersionConvertorFactory_40_50.convertResource(codeSystemR5, ADVISOR_40_50);
936                }
937
938                @Override
939                public IBaseResource valueSetFromCanonical(ValueSet theValueSet) {
940                        org.hl7.fhir.r5.model.ValueSet valueSetR5 = (org.hl7.fhir.r5.model.ValueSet)
941                                        VersionConvertorFactory_40_50.convertResource(theValueSet, ADVISOR_40_50);
942                        return VersionConvertorFactory_43_50.convertResource(valueSetR5, ADVISOR_43_50);
943                }
944
945                @Override
946                public IBaseResource codeSystemFromCanonical(CodeSystem theCodeSystem) {
947                        org.hl7.fhir.r5.model.CodeSystem codeSystemR5 = (org.hl7.fhir.r5.model.CodeSystem)
948                                        VersionConvertorFactory_40_50.convertResource(theCodeSystem, ADVISOR_40_50);
949                        return VersionConvertorFactory_43_50.convertResource(codeSystemR5, ADVISOR_43_50);
950                }
951
952                @Override
953                public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) {
954                        org.hl7.fhir.r5.model.ConceptMap conceptMapR5 =
955                                        (org.hl7.fhir.r5.model.ConceptMap) VersionConvertorFactory_43_50.convertResource(
956                                                        (org.hl7.fhir.r4b.model.Resource) theConceptMap, ADVISOR_43_50);
957                        return (ConceptMap) VersionConvertorFactory_40_50.convertResource(conceptMapR5, ADVISOR_40_50);
958                }
959
960                @Override
961                public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) {
962                        return (SearchParameter) VersionConvertorFactory_43_50.convertResource(
963                                        (org.hl7.fhir.r4b.model.Resource) theSearchParameter, ADVISOR_43_50);
964                }
965
966                @Override
967                public IBaseParameters parametersFromCanonical(Parameters theParameters) {
968                        org.hl7.fhir.r5.model.Parameters parametersR5 = (org.hl7.fhir.r5.model.Parameters)
969                                        VersionConvertorFactory_40_50.convertResource(theParameters, ADVISOR_40_50);
970                        return (IBaseParameters) VersionConvertorFactory_43_50.convertResource(parametersR5, ADVISOR_43_50);
971                }
972
973                @Override
974                public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) {
975                        return (StructureDefinition) VersionConvertorFactory_43_50.convertResource(
976                                        (org.hl7.fhir.r4b.model.Resource) theResource, ADVISOR_43_50);
977                }
978
979                @Override
980                public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) {
981                        return VersionConvertorFactory_43_50.convertResource(theResource, ADVISOR_43_50);
982                }
983
984                @Override
985                public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) {
986                        return VersionConvertorFactory_43_50.convertResource(theResource, ADVISOR_43_50);
987                }
988
989                @Override
990                public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) {
991                        return VersionConvertorFactory_43_50.convertResource(
992                                        (org.hl7.fhir.r4b.model.Resource) theResource, ADVISOR_43_50);
993                }
994
995                @Override
996                public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) {
997                        return (org.hl7.fhir.r5.model.ValueSet) VersionConvertorFactory_43_50.convertResource(
998                                        (org.hl7.fhir.r4b.model.Resource) theResource, ADVISOR_43_50);
999                }
1000
1001                @Override
1002                public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) {
1003                        return (org.hl7.fhir.r5.model.CodeSystem) VersionConvertorFactory_43_50.convertResource(
1004                                        (org.hl7.fhir.r4b.model.Resource) theResource, ADVISOR_43_50);
1005                }
1006
1007                @Override
1008                public IBaseResource searchParameterFromCanonical(SearchParameter theResource) {
1009                        return VersionConvertorFactory_43_50.convertResource(theResource, ADVISOR_43_50);
1010                }
1011
1012                @Override
1013                public IBaseResource auditEventFromCanonical(AuditEvent theResource) {
1014                        org.hl7.fhir.r5.model.AuditEvent r5 = (org.hl7.fhir.r5.model.AuditEvent)
1015                                        VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50);
1016                        return VersionConvertorFactory_43_50.convertResource(r5, ADVISOR_43_50);
1017                }
1018
1019                @Override
1020                public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) {
1021                        return (IBaseConformance) VersionConvertorFactory_43_50.convertResource(theResource, ADVISOR_43_50);
1022                }
1023        }
1024
1025        private static class R5Strategy implements IStrategy {
1026
1027                @Override
1028                public CapabilityStatement capabilityStatementToCanonical(IBaseResource theCapabilityStatement) {
1029                        return (CapabilityStatement) theCapabilityStatement;
1030                }
1031
1032                @Override
1033                public Coding codingToCanonical(IBaseCoding theCoding) {
1034                        return (org.hl7.fhir.r4.model.Coding)
1035                                        VersionConvertorFactory_40_50.convertType((org.hl7.fhir.r5.model.Coding) theCoding, ADVISOR_40_50);
1036                }
1037
1038                @Override
1039                public CodeableConcept codeableConceptToCanonical(IBaseDatatype theCodeableConcept) {
1040                        return (org.hl7.fhir.r4.model.CodeableConcept) VersionConvertorFactory_40_50.convertType(
1041                                        (org.hl7.fhir.r5.model.CodeableConcept) theCodeableConcept, ADVISOR_40_50);
1042                }
1043
1044                @Override
1045                public ValueSet valueSetToCanonical(IBaseResource theValueSet) {
1046                        return (ValueSet) VersionConvertorFactory_40_50.convertResource(
1047                                        (org.hl7.fhir.r5.model.ValueSet) theValueSet, ADVISOR_40_50);
1048                }
1049
1050                @Override
1051                public CodeSystem codeSystemToCanonical(IBaseResource theCodeSystem) {
1052                        return (CodeSystem) VersionConvertorFactory_40_50.convertResource(
1053                                        (org.hl7.fhir.r5.model.CodeSystem) theCodeSystem, ADVISOR_40_50);
1054                }
1055
1056                @Override
1057                public IBaseResource valueSetFromCanonical(ValueSet theValueSet) {
1058                        return VersionConvertorFactory_40_50.convertResource(theValueSet, ADVISOR_40_50);
1059                }
1060
1061                @Override
1062                public IBaseResource codeSystemFromCanonical(CodeSystem theCodeSystem) {
1063                        return VersionConvertorFactory_40_50.convertResource(theCodeSystem, ADVISOR_40_50);
1064                }
1065
1066                @Override
1067                public ConceptMap conceptMapToCanonical(IBaseResource theConceptMap) {
1068                        return (ConceptMap) VersionConvertorFactory_40_50.convertResource(
1069                                        (org.hl7.fhir.r5.model.ConceptMap) theConceptMap, ADVISOR_40_50);
1070                }
1071
1072                @Override
1073                public SearchParameter searchParameterToCanonical(IBaseResource theSearchParameter) {
1074                        return (SearchParameter) theSearchParameter;
1075                }
1076
1077                @Override
1078                public IBaseParameters parametersFromCanonical(Parameters theParameters) {
1079                        return (IBaseParameters) VersionConvertorFactory_40_50.convertResource(theParameters, ADVISOR_40_50);
1080                }
1081
1082                @Override
1083                public StructureDefinition structureDefinitionToCanonical(IBaseResource theResource) {
1084                        return (StructureDefinition) theResource;
1085                }
1086
1087                @Override
1088                public IBaseResource structureDefinitionFromCanonical(StructureDefinition theResource) {
1089                        return theResource;
1090                }
1091
1092                @Override
1093                public IBaseResource valueSetFromValidatorCanonical(org.hl7.fhir.r5.model.ValueSet theResource) {
1094                        return theResource;
1095                }
1096
1097                @Override
1098                public org.hl7.fhir.r5.model.Resource resourceToValidatorCanonical(IBaseResource theResource) {
1099                        return (org.hl7.fhir.r5.model.Resource) theResource;
1100                }
1101
1102                @Override
1103                public org.hl7.fhir.r5.model.ValueSet valueSetToValidatorCanonical(IBaseResource theResource) {
1104                        return (org.hl7.fhir.r5.model.ValueSet) theResource;
1105                }
1106
1107                @Override
1108                public org.hl7.fhir.r5.model.CodeSystem codeSystemToValidatorCanonical(IBaseResource theResource) {
1109                        return (org.hl7.fhir.r5.model.CodeSystem) theResource;
1110                }
1111
1112                @Override
1113                public IBaseResource searchParameterFromCanonical(SearchParameter theResource) {
1114                        return theResource;
1115                }
1116
1117                @Override
1118                public IBaseResource auditEventFromCanonical(AuditEvent theResource) {
1119                        return VersionConvertorFactory_40_50.convertResource(theResource, ADVISOR_40_50);
1120                }
1121
1122                @Override
1123                public IBaseConformance capabilityStatementFromCanonical(CapabilityStatement theResource) {
1124                        return theResource;
1125                }
1126        }
1127}