Source code

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