001package org.hl7.fhir.convertors.conv40_50.resources40_50; 002 003import java.util.stream.Collectors; 004 005import org.hl7.fhir.convertors.context.ConversionContext40_50; 006import org.hl7.fhir.convertors.conv40_50.datatypes40_50.general40_50.CodeableConcept40_50; 007import org.hl7.fhir.convertors.conv40_50.datatypes40_50.general40_50.Coding40_50; 008import org.hl7.fhir.convertors.conv40_50.datatypes40_50.metadata40_50.ContactDetail40_50; 009import org.hl7.fhir.convertors.conv40_50.datatypes40_50.metadata40_50.UsageContext40_50; 010import org.hl7.fhir.convertors.conv40_50.datatypes40_50.primitive40_50.Boolean40_50; 011import org.hl7.fhir.convertors.conv40_50.datatypes40_50.primitive40_50.Canonical40_50; 012import org.hl7.fhir.convertors.conv40_50.datatypes40_50.primitive40_50.Code40_50; 013import org.hl7.fhir.convertors.conv40_50.datatypes40_50.primitive40_50.DateTime40_50; 014import org.hl7.fhir.convertors.conv40_50.datatypes40_50.primitive40_50.MarkDown40_50; 015import org.hl7.fhir.convertors.conv40_50.datatypes40_50.primitive40_50.String40_50; 016import org.hl7.fhir.convertors.conv40_50.datatypes40_50.primitive40_50.UnsignedInt40_50; 017import org.hl7.fhir.convertors.conv40_50.datatypes40_50.primitive40_50.Uri40_50; 018import org.hl7.fhir.convertors.conv40_50.datatypes40_50.primitive40_50.Url40_50; 019import org.hl7.fhir.convertors.conv40_50.datatypes40_50.special40_50.Reference40_50; 020import org.hl7.fhir.exceptions.FHIRException; 021import org.hl7.fhir.r4.model.CapabilityStatement; 022import org.hl7.fhir.r5.model.Enumeration; 023import org.hl7.fhir.r5.model.Enumerations; 024 025/* 026 Copyright (c) 2011+, HL7, Inc. 027 All rights reserved. 028 029 Redistribution and use in source and binary forms, with or without modification, 030 are permitted provided that the following conditions are met: 031 032 * Redistributions of source code must retain the above copyright notice, this 033 list of conditions and the following disclaimer. 034 * Redistributions in binary form must reproduce the above copyright notice, 035 this list of conditions and the following disclaimer in the documentation 036 and/or other materials provided with the distribution. 037 * Neither the name of HL7 nor the names of its contributors may be used to 038 endorse or promote products derived from this software without specific 039 prior written permission. 040 041 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 042 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 043 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 044 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 045 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 046 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 047 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 048 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 049 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 050 POSSIBILITY OF SUCH DAMAGE. 051 052*/ 053// Generated on Sun, Feb 24, 2019 11:37+1100 for FHIR v4.0.0 054public class CapabilityStatement40_50 { 055 056 public static org.hl7.fhir.r5.model.CapabilityStatement convertCapabilityStatement(org.hl7.fhir.r4.model.CapabilityStatement src) throws FHIRException { 057 if (src == null) 058 return null; 059 org.hl7.fhir.r5.model.CapabilityStatement tgt = new org.hl7.fhir.r5.model.CapabilityStatement(); 060 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyDomainResource(src, tgt); 061 if (src.hasUrl()) 062 tgt.setUrlElement(Uri40_50.convertUri(src.getUrlElement())); 063 if (src.hasVersion()) 064 tgt.setVersionElement(String40_50.convertString(src.getVersionElement())); 065 if (src.hasName()) 066 tgt.setNameElement(String40_50.convertString(src.getNameElement())); 067 if (src.hasTitle()) 068 tgt.setTitleElement(String40_50.convertString(src.getTitleElement())); 069 if (src.hasStatus()) 070 tgt.setStatusElement(Enumerations40_50.convertPublicationStatus(src.getStatusElement())); 071 if (src.hasExperimental()) 072 tgt.setExperimentalElement(Boolean40_50.convertBoolean(src.getExperimentalElement())); 073 if (src.hasDate()) 074 tgt.setDateElement(DateTime40_50.convertDateTime(src.getDateElement())); 075 if (src.hasPublisher()) 076 tgt.setPublisherElement(String40_50.convertString(src.getPublisherElement())); 077 for (org.hl7.fhir.r4.model.ContactDetail t : src.getContact()) 078 tgt.addContact(ContactDetail40_50.convertContactDetail(t)); 079 if (src.hasDescription()) 080 tgt.setDescriptionElement(MarkDown40_50.convertMarkdown(src.getDescriptionElement())); 081 for (org.hl7.fhir.r4.model.UsageContext t : src.getUseContext()) 082 tgt.addUseContext(UsageContext40_50.convertUsageContext(t)); 083 for (org.hl7.fhir.r4.model.CodeableConcept t : src.getJurisdiction()) 084 tgt.addJurisdiction(CodeableConcept40_50.convertCodeableConcept(t)); 085 if (src.hasPurpose()) 086 tgt.setPurposeElement(MarkDown40_50.convertMarkdown(src.getPurposeElement())); 087 if (src.hasCopyright()) 088 tgt.setCopyrightElement(MarkDown40_50.convertMarkdown(src.getCopyrightElement())); 089 if (src.hasKind()) 090 tgt.setKindElement(convertCapabilityStatementKind(src.getKindElement())); 091 for (org.hl7.fhir.r4.model.CanonicalType t : src.getInstantiates()) 092 tgt.getInstantiates().add(Canonical40_50.convertCanonical(t)); 093 for (org.hl7.fhir.r4.model.CanonicalType t : src.getImports()) 094 tgt.getImports().add(Canonical40_50.convertCanonical(t)); 095 if (src.hasSoftware()) 096 tgt.setSoftware(convertCapabilityStatementSoftwareComponent(src.getSoftware())); 097 if (src.hasImplementation()) 098 tgt.setImplementation(convertCapabilityStatementImplementationComponent(src.getImplementation())); 099 if (src.hasFhirVersion()) 100 tgt.setFhirVersionElement(Enumerations40_50.convertFHIRVersion(src.getFhirVersionElement())); 101 for (org.hl7.fhir.r4.model.CodeType t : src.getFormat()) tgt.getFormat().add(Code40_50.convertCode(t)); 102 for (org.hl7.fhir.r4.model.CodeType t : src.getPatchFormat()) tgt.getPatchFormat().add(Code40_50.convertCode(t)); 103 for (org.hl7.fhir.r4.model.CanonicalType t : src.getImplementationGuide()) 104 tgt.getImplementationGuide().add(Canonical40_50.convertCanonical(t)); 105 for (org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestComponent t : src.getRest()) 106 tgt.addRest(convertCapabilityStatementRestComponent(t)); 107 for (org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingComponent t : src.getMessaging()) 108 tgt.addMessaging(convertCapabilityStatementMessagingComponent(t)); 109 for (org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementDocumentComponent t : src.getDocument()) 110 tgt.addDocument(convertCapabilityStatementDocumentComponent(t)); 111 return tgt; 112 } 113 114 public static org.hl7.fhir.r4.model.CapabilityStatement convertCapabilityStatement(org.hl7.fhir.r5.model.CapabilityStatement src) throws FHIRException { 115 if (src == null) 116 return null; 117 org.hl7.fhir.r4.model.CapabilityStatement tgt = new org.hl7.fhir.r4.model.CapabilityStatement(); 118 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyDomainResource(src, tgt); 119 if (src.hasUrl()) 120 tgt.setUrlElement(Uri40_50.convertUri(src.getUrlElement())); 121 if (src.hasVersion()) 122 tgt.setVersionElement(String40_50.convertString(src.getVersionElement())); 123 if (src.hasName()) 124 tgt.setNameElement(String40_50.convertString(src.getNameElement())); 125 if (src.hasTitle()) 126 tgt.setTitleElement(String40_50.convertString(src.getTitleElement())); 127 if (src.hasStatus()) 128 tgt.setStatusElement(Enumerations40_50.convertPublicationStatus(src.getStatusElement())); 129 if (src.hasExperimental()) 130 tgt.setExperimentalElement(Boolean40_50.convertBoolean(src.getExperimentalElement())); 131 if (src.hasDate()) 132 tgt.setDateElement(DateTime40_50.convertDateTime(src.getDateElement())); 133 if (src.hasPublisher()) 134 tgt.setPublisherElement(String40_50.convertString(src.getPublisherElement())); 135 for (org.hl7.fhir.r5.model.ContactDetail t : src.getContact()) 136 tgt.addContact(ContactDetail40_50.convertContactDetail(t)); 137 if (src.hasDescription()) 138 tgt.setDescriptionElement(MarkDown40_50.convertMarkdown(src.getDescriptionElement())); 139 for (org.hl7.fhir.r5.model.UsageContext t : src.getUseContext()) 140 tgt.addUseContext(UsageContext40_50.convertUsageContext(t)); 141 for (org.hl7.fhir.r5.model.CodeableConcept t : src.getJurisdiction()) 142 tgt.addJurisdiction(CodeableConcept40_50.convertCodeableConcept(t)); 143 if (src.hasPurpose()) 144 tgt.setPurposeElement(MarkDown40_50.convertMarkdown(src.getPurposeElement())); 145 if (src.hasCopyright()) 146 tgt.setCopyrightElement(MarkDown40_50.convertMarkdown(src.getCopyrightElement())); 147 if (src.hasKind()) 148 tgt.setKindElement(convertCapabilityStatementKind(src.getKindElement())); 149 for (org.hl7.fhir.r5.model.CanonicalType t : src.getInstantiates()) 150 tgt.getInstantiates().add(Canonical40_50.convertCanonical(t)); 151 for (org.hl7.fhir.r5.model.CanonicalType t : src.getImports()) 152 tgt.getImports().add(Canonical40_50.convertCanonical(t)); 153 if (src.hasSoftware()) 154 tgt.setSoftware(convertCapabilityStatementSoftwareComponent(src.getSoftware())); 155 if (src.hasImplementation()) 156 tgt.setImplementation(convertCapabilityStatementImplementationComponent(src.getImplementation())); 157 if (src.hasFhirVersion()) 158 tgt.setFhirVersionElement(Enumerations40_50.convertFHIRVersion(src.getFhirVersionElement())); 159 for (org.hl7.fhir.r5.model.CodeType t : src.getFormat()) tgt.getFormat().add(Code40_50.convertCode(t)); 160 for (org.hl7.fhir.r5.model.CodeType t : src.getPatchFormat()) tgt.getPatchFormat().add(Code40_50.convertCode(t)); 161 for (org.hl7.fhir.r5.model.CanonicalType t : src.getImplementationGuide()) 162 tgt.getImplementationGuide().add(Canonical40_50.convertCanonical(t)); 163 for (org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestComponent t : src.getRest()) 164 tgt.addRest(convertCapabilityStatementRestComponent(t)); 165 for (org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingComponent t : src.getMessaging()) 166 tgt.addMessaging(convertCapabilityStatementMessagingComponent(t)); 167 for (org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementDocumentComponent t : src.getDocument()) 168 tgt.addDocument(convertCapabilityStatementDocumentComponent(t)); 169 return tgt; 170 } 171 172 static public org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.Enumerations.CapabilityStatementKind> convertCapabilityStatementKind(org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementKind> src) throws FHIRException { 173 if (src == null || src.isEmpty()) 174 return null; 175 Enumeration<Enumerations.CapabilityStatementKind> tgt = new Enumeration<>(new Enumerations.CapabilityStatementKindEnumFactory()); 176 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 177 if (src.getValue() == null) { 178 tgt.setValue(null); 179 } else { 180 switch (src.getValue()) { 181 case INSTANCE: 182 tgt.setValue(Enumerations.CapabilityStatementKind.INSTANCE); 183 break; 184 case CAPABILITY: 185 tgt.setValue(Enumerations.CapabilityStatementKind.CAPABILITY); 186 break; 187 case REQUIREMENTS: 188 tgt.setValue(Enumerations.CapabilityStatementKind.REQUIREMENTS); 189 break; 190 default: 191 tgt.setValue(Enumerations.CapabilityStatementKind.NULL); 192 break; 193 } 194 } 195 return tgt; 196 } 197 198 static public org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementKind> convertCapabilityStatementKind(org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.Enumerations.CapabilityStatementKind> src) throws FHIRException { 199 if (src == null || src.isEmpty()) 200 return null; 201 org.hl7.fhir.r4.model.Enumeration<CapabilityStatement.CapabilityStatementKind> tgt = new org.hl7.fhir.r4.model.Enumeration<>(new CapabilityStatement.CapabilityStatementKindEnumFactory()); 202 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 203 if (src.getValue() == null) { 204 tgt.setValue(null); 205 } else { 206 switch (src.getValue()) { 207 case INSTANCE: 208 tgt.setValue(CapabilityStatement.CapabilityStatementKind.INSTANCE); 209 break; 210 case CAPABILITY: 211 tgt.setValue(CapabilityStatement.CapabilityStatementKind.CAPABILITY); 212 break; 213 case REQUIREMENTS: 214 tgt.setValue(CapabilityStatement.CapabilityStatementKind.REQUIREMENTS); 215 break; 216 default: 217 tgt.setValue(CapabilityStatement.CapabilityStatementKind.NULL); 218 break; 219 } 220 } 221 return tgt; 222 } 223 224 public static org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementSoftwareComponent convertCapabilityStatementSoftwareComponent(org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementSoftwareComponent src) throws FHIRException { 225 if (src == null) 226 return null; 227 org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementSoftwareComponent tgt = new org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementSoftwareComponent(); 228 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 229 if (src.hasName()) 230 tgt.setNameElement(String40_50.convertString(src.getNameElement())); 231 if (src.hasVersion()) 232 tgt.setVersionElement(String40_50.convertString(src.getVersionElement())); 233 if (src.hasReleaseDate()) 234 tgt.setReleaseDateElement(DateTime40_50.convertDateTime(src.getReleaseDateElement())); 235 return tgt; 236 } 237 238 public static org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementSoftwareComponent convertCapabilityStatementSoftwareComponent(org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementSoftwareComponent src) throws FHIRException { 239 if (src == null) 240 return null; 241 org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementSoftwareComponent tgt = new org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementSoftwareComponent(); 242 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 243 if (src.hasName()) 244 tgt.setNameElement(String40_50.convertString(src.getNameElement())); 245 if (src.hasVersion()) 246 tgt.setVersionElement(String40_50.convertString(src.getVersionElement())); 247 if (src.hasReleaseDate()) 248 tgt.setReleaseDateElement(DateTime40_50.convertDateTime(src.getReleaseDateElement())); 249 return tgt; 250 } 251 252 public static org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementImplementationComponent convertCapabilityStatementImplementationComponent(org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementImplementationComponent src) throws FHIRException { 253 if (src == null) 254 return null; 255 org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementImplementationComponent tgt = new org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementImplementationComponent(); 256 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 257 if (src.hasDescription()) 258 tgt.setDescriptionElement(String40_50.convertStringToMarkdown(src.getDescriptionElement())); 259 if (src.hasUrl()) 260 tgt.setUrlElement(Url40_50.convertUrl(src.getUrlElement())); 261 if (src.hasCustodian()) 262 tgt.setCustodian(Reference40_50.convertReference(src.getCustodian())); 263 return tgt; 264 } 265 266 public static org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementImplementationComponent convertCapabilityStatementImplementationComponent(org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementImplementationComponent src) throws FHIRException { 267 if (src == null) 268 return null; 269 org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementImplementationComponent tgt = new org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementImplementationComponent(); 270 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 271 if (src.hasDescription()) 272 tgt.setDescriptionElement(String40_50.convertString(src.getDescriptionElement())); 273 if (src.hasUrl()) 274 tgt.setUrlElement(Url40_50.convertUrl(src.getUrlElement())); 275 if (src.hasCustodian()) 276 tgt.setCustodian(Reference40_50.convertReference(src.getCustodian())); 277 return tgt; 278 } 279 280 public static org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestComponent convertCapabilityStatementRestComponent(org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestComponent src) throws FHIRException { 281 if (src == null) 282 return null; 283 org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestComponent tgt = new org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestComponent(); 284 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 285 if (src.hasMode()) 286 tgt.setModeElement(convertRestfulCapabilityMode(src.getModeElement())); 287 if (src.hasDocumentation()) 288 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 289 if (src.hasSecurity()) 290 tgt.setSecurity(convertCapabilityStatementRestSecurityComponent(src.getSecurity())); 291 for (org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceComponent t : src.getResource()) 292 tgt.addResource(convertCapabilityStatementRestResourceComponent(t)); 293 for (org.hl7.fhir.r4.model.CapabilityStatement.SystemInteractionComponent t : src.getInteraction()) 294 tgt.addInteraction(convertSystemInteractionComponent(t)); 295 for (org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent t : src.getSearchParam()) 296 tgt.addSearchParam(convertCapabilityStatementRestResourceSearchParamComponent(t)); 297 for (org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceOperationComponent t : src.getOperation()) 298 tgt.addOperation(convertCapabilityStatementRestResourceOperationComponent(t)); 299 for (org.hl7.fhir.r4.model.CanonicalType t : src.getCompartment()) 300 tgt.getCompartment().add(Canonical40_50.convertCanonical(t)); 301 return tgt; 302 } 303 304 public static org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestComponent convertCapabilityStatementRestComponent(org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestComponent src) throws FHIRException { 305 if (src == null) 306 return null; 307 org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestComponent tgt = new org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestComponent(); 308 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 309 if (src.hasMode()) 310 tgt.setModeElement(convertRestfulCapabilityMode(src.getModeElement())); 311 if (src.hasDocumentation()) 312 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 313 if (src.hasSecurity()) 314 tgt.setSecurity(convertCapabilityStatementRestSecurityComponent(src.getSecurity())); 315 for (org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceComponent t : src.getResource()) 316 tgt.addResource(convertCapabilityStatementRestResourceComponent(t)); 317 for (org.hl7.fhir.r5.model.CapabilityStatement.SystemInteractionComponent t : src.getInteraction()) 318 tgt.addInteraction(convertSystemInteractionComponent(t)); 319 for (org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent t : src.getSearchParam()) 320 tgt.addSearchParam(convertCapabilityStatementRestResourceSearchParamComponent(t)); 321 for (org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceOperationComponent t : src.getOperation()) 322 tgt.addOperation(convertCapabilityStatementRestResourceOperationComponent(t)); 323 for (org.hl7.fhir.r5.model.CanonicalType t : src.getCompartment()) 324 tgt.getCompartment().add(Canonical40_50.convertCanonical(t)); 325 return tgt; 326 } 327 328 static public org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.RestfulCapabilityMode> convertRestfulCapabilityMode(org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.RestfulCapabilityMode> src) throws FHIRException { 329 if (src == null || src.isEmpty()) 330 return null; 331 Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.RestfulCapabilityMode> tgt = new Enumeration<>(new org.hl7.fhir.r5.model.CapabilityStatement.RestfulCapabilityModeEnumFactory()); 332 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 333 if (src.getValue() == null) { 334 tgt.setValue(null); 335 } else { 336 switch (src.getValue()) { 337 case CLIENT: 338 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.RestfulCapabilityMode.CLIENT); 339 break; 340 case SERVER: 341 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.RestfulCapabilityMode.SERVER); 342 break; 343 default: 344 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.RestfulCapabilityMode.NULL); 345 break; 346 } 347 } 348 return tgt; 349 } 350 351 static public org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.RestfulCapabilityMode> convertRestfulCapabilityMode(org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.RestfulCapabilityMode> src) throws FHIRException { 352 if (src == null || src.isEmpty()) 353 return null; 354 org.hl7.fhir.r4.model.Enumeration<CapabilityStatement.RestfulCapabilityMode> tgt = new org.hl7.fhir.r4.model.Enumeration<>(new CapabilityStatement.RestfulCapabilityModeEnumFactory()); 355 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 356 if (src.getValue() == null) { 357 tgt.setValue(null); 358 } else { 359 switch (src.getValue()) { 360 case CLIENT: 361 tgt.setValue(CapabilityStatement.RestfulCapabilityMode.CLIENT); 362 break; 363 case SERVER: 364 tgt.setValue(CapabilityStatement.RestfulCapabilityMode.SERVER); 365 break; 366 default: 367 tgt.setValue(CapabilityStatement.RestfulCapabilityMode.NULL); 368 break; 369 } 370 } 371 return tgt; 372 } 373 374 public static org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestSecurityComponent convertCapabilityStatementRestSecurityComponent(org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestSecurityComponent src) throws FHIRException { 375 if (src == null) 376 return null; 377 org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestSecurityComponent tgt = new org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestSecurityComponent(); 378 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 379 if (src.hasCors()) 380 tgt.setCorsElement(Boolean40_50.convertBoolean(src.getCorsElement())); 381 for (org.hl7.fhir.r4.model.CodeableConcept t : src.getService()) 382 tgt.addService(CodeableConcept40_50.convertCodeableConcept(t)); 383 if (src.hasDescription()) 384 tgt.setDescriptionElement(MarkDown40_50.convertMarkdown(src.getDescriptionElement())); 385 return tgt; 386 } 387 388 public static org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestSecurityComponent convertCapabilityStatementRestSecurityComponent(org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestSecurityComponent src) throws FHIRException { 389 if (src == null) 390 return null; 391 org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestSecurityComponent tgt = new org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestSecurityComponent(); 392 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 393 if (src.hasCors()) 394 tgt.setCorsElement(Boolean40_50.convertBoolean(src.getCorsElement())); 395 for (org.hl7.fhir.r5.model.CodeableConcept t : src.getService()) 396 tgt.addService(CodeableConcept40_50.convertCodeableConcept(t)); 397 if (src.hasDescription()) 398 tgt.setDescriptionElement(MarkDown40_50.convertMarkdown(src.getDescriptionElement())); 399 return tgt; 400 } 401 402 public static org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceComponent convertCapabilityStatementRestResourceComponent(org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceComponent src) throws FHIRException { 403 if (src == null) 404 return null; 405 org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceComponent tgt = new org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceComponent(); 406 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 407 if (src.hasType()) 408 tgt.setTypeElement(Code40_50.convertCode(src.getTypeElement())); 409 if (src.hasProfile()) 410 tgt.setProfileElement(Canonical40_50.convertCanonical(src.getProfileElement())); 411 for (org.hl7.fhir.r4.model.CanonicalType t : src.getSupportedProfile()) 412 tgt.getSupportedProfile().add(Canonical40_50.convertCanonical(t)); 413 if (src.hasDocumentation()) 414 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 415 for (org.hl7.fhir.r4.model.CapabilityStatement.ResourceInteractionComponent t : src.getInteraction()) 416 tgt.addInteraction(convertResourceInteractionComponent(t)); 417 if (src.hasVersioning()) 418 tgt.setVersioningElement(convertResourceVersionPolicy(src.getVersioningElement())); 419 if (src.hasReadHistory()) 420 tgt.setReadHistoryElement(Boolean40_50.convertBoolean(src.getReadHistoryElement())); 421 if (src.hasUpdateCreate()) 422 tgt.setUpdateCreateElement(Boolean40_50.convertBoolean(src.getUpdateCreateElement())); 423 if (src.hasConditionalCreate()) 424 tgt.setConditionalCreateElement(Boolean40_50.convertBoolean(src.getConditionalCreateElement())); 425 if (src.hasConditionalRead()) 426 tgt.setConditionalReadElement(convertConditionalReadStatus(src.getConditionalReadElement())); 427 if (src.hasConditionalUpdate()) 428 tgt.setConditionalUpdateElement(Boolean40_50.convertBoolean(src.getConditionalUpdateElement())); 429 if (src.hasConditionalDelete()) 430 tgt.setConditionalDeleteElement(convertConditionalDeleteStatus(src.getConditionalDeleteElement())); 431 tgt.setReferencePolicy(src.getReferencePolicy().stream() 432 .map(CapabilityStatement40_50::convertReferenceHandlingPolicy) 433 .collect(Collectors.toList())); 434 for (org.hl7.fhir.r4.model.StringType t : src.getSearchInclude()) 435 tgt.getSearchInclude().add(String40_50.convertString(t)); 436 for (org.hl7.fhir.r4.model.StringType t : src.getSearchRevInclude()) 437 tgt.getSearchRevInclude().add(String40_50.convertString(t)); 438 for (org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent t : src.getSearchParam()) 439 tgt.addSearchParam(convertCapabilityStatementRestResourceSearchParamComponent(t)); 440 for (org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceOperationComponent t : src.getOperation()) 441 tgt.addOperation(convertCapabilityStatementRestResourceOperationComponent(t)); 442 return tgt; 443 } 444 445 public static org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceComponent convertCapabilityStatementRestResourceComponent(org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceComponent src) throws FHIRException { 446 if (src == null) 447 return null; 448 org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceComponent tgt = new org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceComponent(); 449 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 450 if (src.hasType()) 451 tgt.setTypeElement(Code40_50.convertCode(src.getTypeElement())); 452 if (src.hasProfile()) 453 tgt.setProfileElement(Canonical40_50.convertCanonical(src.getProfileElement())); 454 for (org.hl7.fhir.r5.model.CanonicalType t : src.getSupportedProfile()) 455 tgt.getSupportedProfile().add(Canonical40_50.convertCanonical(t)); 456 if (src.hasDocumentation()) 457 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 458 for (org.hl7.fhir.r5.model.CapabilityStatement.ResourceInteractionComponent t : src.getInteraction()) 459 tgt.addInteraction(convertResourceInteractionComponent(t)); 460 if (src.hasVersioning()) 461 tgt.setVersioningElement(convertResourceVersionPolicy(src.getVersioningElement())); 462 if (src.hasReadHistory()) 463 tgt.setReadHistoryElement(Boolean40_50.convertBoolean(src.getReadHistoryElement())); 464 if (src.hasUpdateCreate()) 465 tgt.setUpdateCreateElement(Boolean40_50.convertBoolean(src.getUpdateCreateElement())); 466 if (src.hasConditionalCreate()) 467 tgt.setConditionalCreateElement(Boolean40_50.convertBoolean(src.getConditionalCreateElement())); 468 if (src.hasConditionalRead()) 469 tgt.setConditionalReadElement(convertConditionalReadStatus(src.getConditionalReadElement())); 470 if (src.hasConditionalUpdate()) 471 tgt.setConditionalUpdateElement(Boolean40_50.convertBoolean(src.getConditionalUpdateElement())); 472 if (src.hasConditionalDelete()) 473 tgt.setConditionalDeleteElement(convertConditionalDeleteStatus(src.getConditionalDeleteElement())); 474 tgt.setReferencePolicy(src.getReferencePolicy().stream() 475 .map(CapabilityStatement40_50::convertReferenceHandlingPolicy) 476 .collect(Collectors.toList())); 477 for (org.hl7.fhir.r5.model.StringType t : src.getSearchInclude()) 478 tgt.getSearchInclude().add(String40_50.convertString(t)); 479 for (org.hl7.fhir.r5.model.StringType t : src.getSearchRevInclude()) 480 tgt.getSearchRevInclude().add(String40_50.convertString(t)); 481 for (org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent t : src.getSearchParam()) 482 tgt.addSearchParam(convertCapabilityStatementRestResourceSearchParamComponent(t)); 483 for (org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceOperationComponent t : src.getOperation()) 484 tgt.addOperation(convertCapabilityStatementRestResourceOperationComponent(t)); 485 return tgt; 486 } 487 488 static public org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.ResourceVersionPolicy> convertResourceVersionPolicy(org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.ResourceVersionPolicy> src) throws FHIRException { 489 if (src == null || src.isEmpty()) 490 return null; 491 Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.ResourceVersionPolicy> tgt = new Enumeration<>(new org.hl7.fhir.r5.model.CapabilityStatement.ResourceVersionPolicyEnumFactory()); 492 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 493 if (src.getValue() == null) { 494 tgt.setValue(null); 495 } else { 496 switch (src.getValue()) { 497 case NOVERSION: 498 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ResourceVersionPolicy.NOVERSION); 499 break; 500 case VERSIONED: 501 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ResourceVersionPolicy.VERSIONED); 502 break; 503 case VERSIONEDUPDATE: 504 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ResourceVersionPolicy.VERSIONEDUPDATE); 505 break; 506 default: 507 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ResourceVersionPolicy.NULL); 508 break; 509 } 510 } 511 return tgt; 512 } 513 514 static public org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.ResourceVersionPolicy> convertResourceVersionPolicy(org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.ResourceVersionPolicy> src) throws FHIRException { 515 if (src == null || src.isEmpty()) 516 return null; 517 org.hl7.fhir.r4.model.Enumeration<CapabilityStatement.ResourceVersionPolicy> tgt = new org.hl7.fhir.r4.model.Enumeration<>(new CapabilityStatement.ResourceVersionPolicyEnumFactory()); 518 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 519 if (src.getValue() == null) { 520 tgt.setValue(null); 521 } else { 522 switch (src.getValue()) { 523 case NOVERSION: 524 tgt.setValue(CapabilityStatement.ResourceVersionPolicy.NOVERSION); 525 break; 526 case VERSIONED: 527 tgt.setValue(CapabilityStatement.ResourceVersionPolicy.VERSIONED); 528 break; 529 case VERSIONEDUPDATE: 530 tgt.setValue(CapabilityStatement.ResourceVersionPolicy.VERSIONEDUPDATE); 531 break; 532 default: 533 tgt.setValue(CapabilityStatement.ResourceVersionPolicy.NULL); 534 break; 535 } 536 } 537 return tgt; 538 } 539 540 static public org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.ConditionalReadStatus> convertConditionalReadStatus(org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.ConditionalReadStatus> src) throws FHIRException { 541 if (src == null || src.isEmpty()) 542 return null; 543 Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.ConditionalReadStatus> tgt = new Enumeration<>(new org.hl7.fhir.r5.model.CapabilityStatement.ConditionalReadStatusEnumFactory()); 544 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 545 if (src.getValue() == null) { 546 tgt.setValue(null); 547 } else { 548 switch (src.getValue()) { 549 case NOTSUPPORTED: 550 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ConditionalReadStatus.NOTSUPPORTED); 551 break; 552 case MODIFIEDSINCE: 553 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ConditionalReadStatus.MODIFIEDSINCE); 554 break; 555 case NOTMATCH: 556 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ConditionalReadStatus.NOTMATCH); 557 break; 558 case FULLSUPPORT: 559 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ConditionalReadStatus.FULLSUPPORT); 560 break; 561 default: 562 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ConditionalReadStatus.NULL); 563 break; 564 } 565 } 566 return tgt; 567 } 568 569 static public org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.ConditionalReadStatus> convertConditionalReadStatus(org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.ConditionalReadStatus> src) throws FHIRException { 570 if (src == null || src.isEmpty()) 571 return null; 572 org.hl7.fhir.r4.model.Enumeration<CapabilityStatement.ConditionalReadStatus> tgt = new org.hl7.fhir.r4.model.Enumeration<>(new CapabilityStatement.ConditionalReadStatusEnumFactory()); 573 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 574 if (src.getValue() == null) { 575 tgt.setValue(null); 576 } else { 577 switch (src.getValue()) { 578 case NOTSUPPORTED: 579 tgt.setValue(CapabilityStatement.ConditionalReadStatus.NOTSUPPORTED); 580 break; 581 case MODIFIEDSINCE: 582 tgt.setValue(CapabilityStatement.ConditionalReadStatus.MODIFIEDSINCE); 583 break; 584 case NOTMATCH: 585 tgt.setValue(CapabilityStatement.ConditionalReadStatus.NOTMATCH); 586 break; 587 case FULLSUPPORT: 588 tgt.setValue(CapabilityStatement.ConditionalReadStatus.FULLSUPPORT); 589 break; 590 default: 591 tgt.setValue(CapabilityStatement.ConditionalReadStatus.NULL); 592 break; 593 } 594 } 595 return tgt; 596 } 597 598 static public org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.ConditionalDeleteStatus> convertConditionalDeleteStatus(org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.ConditionalDeleteStatus> src) throws FHIRException { 599 if (src == null || src.isEmpty()) 600 return null; 601 Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.ConditionalDeleteStatus> tgt = new Enumeration<>(new org.hl7.fhir.r5.model.CapabilityStatement.ConditionalDeleteStatusEnumFactory()); 602 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 603 if (src.getValue() == null) { 604 tgt.setValue(null); 605 } else { 606 switch (src.getValue()) { 607 case NOTSUPPORTED: 608 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ConditionalDeleteStatus.NOTSUPPORTED); 609 break; 610 case SINGLE: 611 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ConditionalDeleteStatus.SINGLE); 612 break; 613 case MULTIPLE: 614 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ConditionalDeleteStatus.MULTIPLE); 615 break; 616 default: 617 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ConditionalDeleteStatus.NULL); 618 break; 619 } 620 } 621 return tgt; 622 } 623 624 static public org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.ConditionalDeleteStatus> convertConditionalDeleteStatus(org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.ConditionalDeleteStatus> src) throws FHIRException { 625 if (src == null || src.isEmpty()) 626 return null; 627 org.hl7.fhir.r4.model.Enumeration<CapabilityStatement.ConditionalDeleteStatus> tgt = new org.hl7.fhir.r4.model.Enumeration<>(new CapabilityStatement.ConditionalDeleteStatusEnumFactory()); 628 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 629 if (src.getValue() == null) { 630 tgt.setValue(null); 631 } else { 632 switch (src.getValue()) { 633 case NOTSUPPORTED: 634 tgt.setValue(CapabilityStatement.ConditionalDeleteStatus.NOTSUPPORTED); 635 break; 636 case SINGLE: 637 tgt.setValue(CapabilityStatement.ConditionalDeleteStatus.SINGLE); 638 break; 639 case MULTIPLE: 640 tgt.setValue(CapabilityStatement.ConditionalDeleteStatus.MULTIPLE); 641 break; 642 default: 643 tgt.setValue(CapabilityStatement.ConditionalDeleteStatus.NULL); 644 break; 645 } 646 } 647 return tgt; 648 } 649 650 static public org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.ReferenceHandlingPolicy> convertReferenceHandlingPolicy(org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.ReferenceHandlingPolicy> src) throws FHIRException { 651 if (src == null || src.isEmpty()) 652 return null; 653 Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.ReferenceHandlingPolicy> tgt = new Enumeration<>(new org.hl7.fhir.r5.model.CapabilityStatement.ReferenceHandlingPolicyEnumFactory()); 654 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 655 if (src.getValue() == null) { 656 tgt.setValue(null); 657 } else { 658 switch (src.getValue()) { 659 case LITERAL: 660 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ReferenceHandlingPolicy.LITERAL); 661 break; 662 case LOGICAL: 663 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ReferenceHandlingPolicy.LOGICAL); 664 break; 665 case RESOLVES: 666 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ReferenceHandlingPolicy.RESOLVES); 667 break; 668 case ENFORCED: 669 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ReferenceHandlingPolicy.ENFORCED); 670 break; 671 case LOCAL: 672 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ReferenceHandlingPolicy.LOCAL); 673 break; 674 default: 675 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.ReferenceHandlingPolicy.NULL); 676 break; 677 } 678 } 679 return tgt; 680 } 681 682 static public org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.ReferenceHandlingPolicy> convertReferenceHandlingPolicy(org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.ReferenceHandlingPolicy> src) throws FHIRException { 683 if (src == null || src.isEmpty()) 684 return null; 685 org.hl7.fhir.r4.model.Enumeration<CapabilityStatement.ReferenceHandlingPolicy> tgt = new org.hl7.fhir.r4.model.Enumeration<>(new CapabilityStatement.ReferenceHandlingPolicyEnumFactory()); 686 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 687 if (src.getValue() == null) { 688 tgt.setValue(null); 689 } else { 690 switch (src.getValue()) { 691 case LITERAL: 692 tgt.setValue(CapabilityStatement.ReferenceHandlingPolicy.LITERAL); 693 break; 694 case LOGICAL: 695 tgt.setValue(CapabilityStatement.ReferenceHandlingPolicy.LOGICAL); 696 break; 697 case RESOLVES: 698 tgt.setValue(CapabilityStatement.ReferenceHandlingPolicy.RESOLVES); 699 break; 700 case ENFORCED: 701 tgt.setValue(CapabilityStatement.ReferenceHandlingPolicy.ENFORCED); 702 break; 703 case LOCAL: 704 tgt.setValue(CapabilityStatement.ReferenceHandlingPolicy.LOCAL); 705 break; 706 default: 707 tgt.setValue(CapabilityStatement.ReferenceHandlingPolicy.NULL); 708 break; 709 } 710 } 711 return tgt; 712 } 713 714 public static org.hl7.fhir.r5.model.CapabilityStatement.ResourceInteractionComponent convertResourceInteractionComponent(org.hl7.fhir.r4.model.CapabilityStatement.ResourceInteractionComponent src) throws FHIRException { 715 if (src == null) 716 return null; 717 org.hl7.fhir.r5.model.CapabilityStatement.ResourceInteractionComponent tgt = new org.hl7.fhir.r5.model.CapabilityStatement.ResourceInteractionComponent(); 718 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 719 if (src.hasCode()) 720 tgt.setCodeElement(convertTypeRestfulInteraction(src.getCodeElement())); 721 if (src.hasDocumentation()) 722 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 723 return tgt; 724 } 725 726 public static org.hl7.fhir.r4.model.CapabilityStatement.ResourceInteractionComponent convertResourceInteractionComponent(org.hl7.fhir.r5.model.CapabilityStatement.ResourceInteractionComponent src) throws FHIRException { 727 if (src == null) 728 return null; 729 org.hl7.fhir.r4.model.CapabilityStatement.ResourceInteractionComponent tgt = new org.hl7.fhir.r4.model.CapabilityStatement.ResourceInteractionComponent(); 730 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 731 if (src.hasCode()) 732 tgt.setCodeElement(convertTypeRestfulInteraction(src.getCodeElement())); 733 if (src.hasDocumentation()) 734 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 735 return tgt; 736 } 737 738 static public org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.TypeRestfulInteraction> convertTypeRestfulInteraction(org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.TypeRestfulInteraction> src) throws FHIRException { 739 if (src == null || src.isEmpty()) 740 return null; 741 Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.TypeRestfulInteraction> tgt = new Enumeration<>(new org.hl7.fhir.r5.model.CapabilityStatement.TypeRestfulInteractionEnumFactory()); 742 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 743 if (src.getValue() == null) { 744 tgt.setValue(null); 745 } else { 746 switch (src.getValue()) { 747 case READ: 748 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.TypeRestfulInteraction.READ); 749 break; 750 case VREAD: 751 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.TypeRestfulInteraction.VREAD); 752 break; 753 case UPDATE: 754 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.TypeRestfulInteraction.UPDATE); 755 break; 756 case PATCH: 757 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.TypeRestfulInteraction.PATCH); 758 break; 759 case DELETE: 760 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.TypeRestfulInteraction.DELETE); 761 break; 762 case HISTORYINSTANCE: 763 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.TypeRestfulInteraction.HISTORYINSTANCE); 764 break; 765 case HISTORYTYPE: 766 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.TypeRestfulInteraction.HISTORYTYPE); 767 break; 768 case CREATE: 769 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.TypeRestfulInteraction.CREATE); 770 break; 771 case SEARCHTYPE: 772 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.TypeRestfulInteraction.SEARCHTYPE); 773 break; 774 default: 775 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.TypeRestfulInteraction.NULL); 776 break; 777 } 778 } 779 return tgt; 780 } 781 782 static public org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.TypeRestfulInteraction> convertTypeRestfulInteraction(org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.TypeRestfulInteraction> src) throws FHIRException { 783 if (src == null || src.isEmpty()) 784 return null; 785 org.hl7.fhir.r4.model.Enumeration<CapabilityStatement.TypeRestfulInteraction> tgt = new org.hl7.fhir.r4.model.Enumeration<>(new CapabilityStatement.TypeRestfulInteractionEnumFactory()); 786 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 787 if (src.getValue() == null) { 788 tgt.setValue(null); 789 } else { 790 switch (src.getValue()) { 791 case READ: 792 tgt.setValue(CapabilityStatement.TypeRestfulInteraction.READ); 793 break; 794 case VREAD: 795 tgt.setValue(CapabilityStatement.TypeRestfulInteraction.VREAD); 796 break; 797 case UPDATE: 798 tgt.setValue(CapabilityStatement.TypeRestfulInteraction.UPDATE); 799 break; 800 case PATCH: 801 tgt.setValue(CapabilityStatement.TypeRestfulInteraction.PATCH); 802 break; 803 case DELETE: 804 tgt.setValue(CapabilityStatement.TypeRestfulInteraction.DELETE); 805 break; 806 case HISTORYINSTANCE: 807 tgt.setValue(CapabilityStatement.TypeRestfulInteraction.HISTORYINSTANCE); 808 break; 809 case HISTORYTYPE: 810 tgt.setValue(CapabilityStatement.TypeRestfulInteraction.HISTORYTYPE); 811 break; 812 case CREATE: 813 tgt.setValue(CapabilityStatement.TypeRestfulInteraction.CREATE); 814 break; 815 case SEARCHTYPE: 816 tgt.setValue(CapabilityStatement.TypeRestfulInteraction.SEARCHTYPE); 817 break; 818 default: 819 tgt.setValue(CapabilityStatement.TypeRestfulInteraction.NULL); 820 break; 821 } 822 } 823 return tgt; 824 } 825 826 public static org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent convertCapabilityStatementRestResourceSearchParamComponent(org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent src) throws FHIRException { 827 if (src == null) 828 return null; 829 org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent tgt = new org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent(); 830 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 831 if (src.hasName()) 832 tgt.setNameElement(String40_50.convertString(src.getNameElement())); 833 if (src.hasDefinition()) 834 tgt.setDefinitionElement(Canonical40_50.convertCanonical(src.getDefinitionElement())); 835 if (src.hasType()) 836 tgt.setTypeElement(Enumerations40_50.convertSearchParamType(src.getTypeElement())); 837 if (src.hasDocumentation()) 838 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 839 return tgt; 840 } 841 842 public static org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent convertCapabilityStatementRestResourceSearchParamComponent(org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent src) throws FHIRException { 843 if (src == null) 844 return null; 845 org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent tgt = new org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceSearchParamComponent(); 846 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 847 if (src.hasName()) 848 tgt.setNameElement(String40_50.convertString(src.getNameElement())); 849 if (src.hasDefinition()) 850 tgt.setDefinitionElement(Canonical40_50.convertCanonical(src.getDefinitionElement())); 851 if (src.hasType()) 852 tgt.setTypeElement(Enumerations40_50.convertSearchParamType(src.getTypeElement())); 853 if (src.hasDocumentation()) 854 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 855 return tgt; 856 } 857 858 public static org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceOperationComponent convertCapabilityStatementRestResourceOperationComponent(org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceOperationComponent src) throws FHIRException { 859 if (src == null) 860 return null; 861 org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceOperationComponent tgt = new org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceOperationComponent(); 862 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 863 if (src.hasName()) 864 tgt.setNameElement(String40_50.convertString(src.getNameElement())); 865 if (src.hasDefinition()) 866 tgt.setDefinitionElement(Canonical40_50.convertCanonical(src.getDefinitionElement())); 867 if (src.hasDocumentation()) 868 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 869 return tgt; 870 } 871 872 public static org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceOperationComponent convertCapabilityStatementRestResourceOperationComponent(org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementRestResourceOperationComponent src) throws FHIRException { 873 if (src == null) 874 return null; 875 org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceOperationComponent tgt = new org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementRestResourceOperationComponent(); 876 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 877 if (src.hasName()) 878 tgt.setNameElement(String40_50.convertString(src.getNameElement())); 879 if (src.hasDefinition()) 880 tgt.setDefinitionElement(Canonical40_50.convertCanonical(src.getDefinitionElement())); 881 if (src.hasDocumentation()) 882 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 883 return tgt; 884 } 885 886 public static org.hl7.fhir.r5.model.CapabilityStatement.SystemInteractionComponent convertSystemInteractionComponent(org.hl7.fhir.r4.model.CapabilityStatement.SystemInteractionComponent src) throws FHIRException { 887 if (src == null) 888 return null; 889 org.hl7.fhir.r5.model.CapabilityStatement.SystemInteractionComponent tgt = new org.hl7.fhir.r5.model.CapabilityStatement.SystemInteractionComponent(); 890 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 891 if (src.hasCode()) 892 tgt.setCodeElement(convertSystemRestfulInteraction(src.getCodeElement())); 893 if (src.hasDocumentation()) 894 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 895 return tgt; 896 } 897 898 public static org.hl7.fhir.r4.model.CapabilityStatement.SystemInteractionComponent convertSystemInteractionComponent(org.hl7.fhir.r5.model.CapabilityStatement.SystemInteractionComponent src) throws FHIRException { 899 if (src == null) 900 return null; 901 org.hl7.fhir.r4.model.CapabilityStatement.SystemInteractionComponent tgt = new org.hl7.fhir.r4.model.CapabilityStatement.SystemInteractionComponent(); 902 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 903 if (src.hasCode()) 904 tgt.setCodeElement(convertSystemRestfulInteraction(src.getCodeElement())); 905 if (src.hasDocumentation()) 906 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 907 return tgt; 908 } 909 910 static public org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.SystemRestfulInteraction> convertSystemRestfulInteraction(org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.SystemRestfulInteraction> src) throws FHIRException { 911 if (src == null || src.isEmpty()) 912 return null; 913 Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.SystemRestfulInteraction> tgt = new Enumeration<>(new org.hl7.fhir.r5.model.CapabilityStatement.SystemRestfulInteractionEnumFactory()); 914 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 915 if (src.getValue() == null) { 916 tgt.setValue(null); 917 } else { 918 switch (src.getValue()) { 919 case TRANSACTION: 920 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.SystemRestfulInteraction.TRANSACTION); 921 break; 922 case BATCH: 923 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.SystemRestfulInteraction.BATCH); 924 break; 925 case SEARCHSYSTEM: 926 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.SystemRestfulInteraction.SEARCHSYSTEM); 927 break; 928 case HISTORYSYSTEM: 929 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.SystemRestfulInteraction.HISTORYSYSTEM); 930 break; 931 default: 932 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.SystemRestfulInteraction.NULL); 933 break; 934 } 935 } 936 return tgt; 937 } 938 939 static public org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.SystemRestfulInteraction> convertSystemRestfulInteraction(org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.SystemRestfulInteraction> src) throws FHIRException { 940 if (src == null || src.isEmpty()) 941 return null; 942 org.hl7.fhir.r4.model.Enumeration<CapabilityStatement.SystemRestfulInteraction> tgt = new org.hl7.fhir.r4.model.Enumeration<>(new CapabilityStatement.SystemRestfulInteractionEnumFactory()); 943 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 944 if (src.getValue() == null) { 945 tgt.setValue(null); 946 } else { 947 switch (src.getValue()) { 948 case TRANSACTION: 949 tgt.setValue(CapabilityStatement.SystemRestfulInteraction.TRANSACTION); 950 break; 951 case BATCH: 952 tgt.setValue(CapabilityStatement.SystemRestfulInteraction.BATCH); 953 break; 954 case SEARCHSYSTEM: 955 tgt.setValue(CapabilityStatement.SystemRestfulInteraction.SEARCHSYSTEM); 956 break; 957 case HISTORYSYSTEM: 958 tgt.setValue(CapabilityStatement.SystemRestfulInteraction.HISTORYSYSTEM); 959 break; 960 default: 961 tgt.setValue(CapabilityStatement.SystemRestfulInteraction.NULL); 962 break; 963 } 964 } 965 return tgt; 966 } 967 968 public static org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingComponent convertCapabilityStatementMessagingComponent(org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingComponent src) throws FHIRException { 969 if (src == null) 970 return null; 971 org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingComponent tgt = new org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingComponent(); 972 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 973 for (org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingEndpointComponent t : src.getEndpoint()) 974 tgt.addEndpoint(convertCapabilityStatementMessagingEndpointComponent(t)); 975 if (src.hasReliableCache()) 976 tgt.setReliableCacheElement(UnsignedInt40_50.convertUnsignedInt(src.getReliableCacheElement())); 977 if (src.hasDocumentation()) 978 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 979 for (org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent t : src.getSupportedMessage()) 980 tgt.addSupportedMessage(convertCapabilityStatementMessagingSupportedMessageComponent(t)); 981 return tgt; 982 } 983 984 public static org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingComponent convertCapabilityStatementMessagingComponent(org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingComponent src) throws FHIRException { 985 if (src == null) 986 return null; 987 org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingComponent tgt = new org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingComponent(); 988 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 989 for (org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingEndpointComponent t : src.getEndpoint()) 990 tgt.addEndpoint(convertCapabilityStatementMessagingEndpointComponent(t)); 991 if (src.hasReliableCache()) 992 tgt.setReliableCacheElement(UnsignedInt40_50.convertUnsignedInt(src.getReliableCacheElement())); 993 if (src.hasDocumentation()) 994 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 995 for (org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent t : src.getSupportedMessage()) 996 tgt.addSupportedMessage(convertCapabilityStatementMessagingSupportedMessageComponent(t)); 997 return tgt; 998 } 999 1000 public static org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingEndpointComponent convertCapabilityStatementMessagingEndpointComponent(org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingEndpointComponent src) throws FHIRException { 1001 if (src == null) 1002 return null; 1003 org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingEndpointComponent tgt = new org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingEndpointComponent(); 1004 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 1005 if (src.hasProtocol()) 1006 tgt.setProtocol(Coding40_50.convertCoding(src.getProtocol())); 1007 if (src.hasAddress()) 1008 tgt.setAddressElement(Url40_50.convertUrl(src.getAddressElement())); 1009 return tgt; 1010 } 1011 1012 public static org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingEndpointComponent convertCapabilityStatementMessagingEndpointComponent(org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingEndpointComponent src) throws FHIRException { 1013 if (src == null) 1014 return null; 1015 org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingEndpointComponent tgt = new org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingEndpointComponent(); 1016 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 1017 if (src.hasProtocol()) 1018 tgt.setProtocol(Coding40_50.convertCoding(src.getProtocol())); 1019 if (src.hasAddress()) 1020 tgt.setAddressElement(Url40_50.convertUrl(src.getAddressElement())); 1021 return tgt; 1022 } 1023 1024 public static org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent convertCapabilityStatementMessagingSupportedMessageComponent(org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent src) throws FHIRException { 1025 if (src == null) 1026 return null; 1027 org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent tgt = new org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent(); 1028 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 1029 if (src.hasMode()) 1030 tgt.setModeElement(convertEventCapabilityMode(src.getModeElement())); 1031 if (src.hasDefinition()) 1032 tgt.setDefinitionElement(Canonical40_50.convertCanonical(src.getDefinitionElement())); 1033 return tgt; 1034 } 1035 1036 public static org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent convertCapabilityStatementMessagingSupportedMessageComponent(org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent src) throws FHIRException { 1037 if (src == null) 1038 return null; 1039 org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent tgt = new org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementMessagingSupportedMessageComponent(); 1040 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 1041 if (src.hasMode()) 1042 tgt.setModeElement(convertEventCapabilityMode(src.getModeElement())); 1043 if (src.hasDefinition()) 1044 tgt.setDefinitionElement(Canonical40_50.convertCanonical(src.getDefinitionElement())); 1045 return tgt; 1046 } 1047 1048 static public org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.EventCapabilityMode> convertEventCapabilityMode(org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.EventCapabilityMode> src) throws FHIRException { 1049 if (src == null || src.isEmpty()) 1050 return null; 1051 Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.EventCapabilityMode> tgt = new Enumeration<>(new org.hl7.fhir.r5.model.CapabilityStatement.EventCapabilityModeEnumFactory()); 1052 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 1053 if (src.getValue() == null) { 1054 tgt.setValue(null); 1055 } else { 1056 switch (src.getValue()) { 1057 case SENDER: 1058 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.EventCapabilityMode.SENDER); 1059 break; 1060 case RECEIVER: 1061 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.EventCapabilityMode.RECEIVER); 1062 break; 1063 default: 1064 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.EventCapabilityMode.NULL); 1065 break; 1066 } 1067 } 1068 return tgt; 1069 } 1070 1071 static public org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.EventCapabilityMode> convertEventCapabilityMode(org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.EventCapabilityMode> src) throws FHIRException { 1072 if (src == null || src.isEmpty()) 1073 return null; 1074 org.hl7.fhir.r4.model.Enumeration<CapabilityStatement.EventCapabilityMode> tgt = new org.hl7.fhir.r4.model.Enumeration<>(new CapabilityStatement.EventCapabilityModeEnumFactory()); 1075 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 1076 if (src.getValue() == null) { 1077 tgt.setValue(null); 1078 } else { 1079 switch (src.getValue()) { 1080 case SENDER: 1081 tgt.setValue(CapabilityStatement.EventCapabilityMode.SENDER); 1082 break; 1083 case RECEIVER: 1084 tgt.setValue(CapabilityStatement.EventCapabilityMode.RECEIVER); 1085 break; 1086 default: 1087 tgt.setValue(CapabilityStatement.EventCapabilityMode.NULL); 1088 break; 1089 } 1090 } 1091 return tgt; 1092 } 1093 1094 public static org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementDocumentComponent convertCapabilityStatementDocumentComponent(org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementDocumentComponent src) throws FHIRException { 1095 if (src == null) 1096 return null; 1097 org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementDocumentComponent tgt = new org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementDocumentComponent(); 1098 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 1099 if (src.hasMode()) 1100 tgt.setModeElement(convertDocumentMode(src.getModeElement())); 1101 if (src.hasDocumentation()) 1102 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 1103 if (src.hasProfile()) 1104 tgt.setProfileElement(Canonical40_50.convertCanonical(src.getProfileElement())); 1105 return tgt; 1106 } 1107 1108 public static org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementDocumentComponent convertCapabilityStatementDocumentComponent(org.hl7.fhir.r5.model.CapabilityStatement.CapabilityStatementDocumentComponent src) throws FHIRException { 1109 if (src == null) 1110 return null; 1111 org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementDocumentComponent tgt = new org.hl7.fhir.r4.model.CapabilityStatement.CapabilityStatementDocumentComponent(); 1112 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyBackboneElement(src, tgt); 1113 if (src.hasMode()) 1114 tgt.setModeElement(convertDocumentMode(src.getModeElement())); 1115 if (src.hasDocumentation()) 1116 tgt.setDocumentationElement(MarkDown40_50.convertMarkdown(src.getDocumentationElement())); 1117 if (src.hasProfile()) 1118 tgt.setProfileElement(Canonical40_50.convertCanonical(src.getProfileElement())); 1119 return tgt; 1120 } 1121 1122 static public org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.DocumentMode> convertDocumentMode(org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.DocumentMode> src) throws FHIRException { 1123 if (src == null || src.isEmpty()) 1124 return null; 1125 Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.DocumentMode> tgt = new Enumeration<>(new org.hl7.fhir.r5.model.CapabilityStatement.DocumentModeEnumFactory()); 1126 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 1127 if (src.getValue() == null) { 1128 tgt.setValue(null); 1129 } else { 1130 switch (src.getValue()) { 1131 case PRODUCER: 1132 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.DocumentMode.PRODUCER); 1133 break; 1134 case CONSUMER: 1135 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.DocumentMode.CONSUMER); 1136 break; 1137 default: 1138 tgt.setValue(org.hl7.fhir.r5.model.CapabilityStatement.DocumentMode.NULL); 1139 break; 1140 } 1141 } 1142 return tgt; 1143 } 1144 1145 static public org.hl7.fhir.r4.model.Enumeration<org.hl7.fhir.r4.model.CapabilityStatement.DocumentMode> convertDocumentMode(org.hl7.fhir.r5.model.Enumeration<org.hl7.fhir.r5.model.CapabilityStatement.DocumentMode> src) throws FHIRException { 1146 if (src == null || src.isEmpty()) 1147 return null; 1148 org.hl7.fhir.r4.model.Enumeration<CapabilityStatement.DocumentMode> tgt = new org.hl7.fhir.r4.model.Enumeration<>(new CapabilityStatement.DocumentModeEnumFactory()); 1149 ConversionContext40_50.INSTANCE.getVersionConvertor_40_50().copyElement(src, tgt); 1150 if (src.getValue() == null) { 1151 tgt.setValue(null); 1152 } else { 1153 switch (src.getValue()) { 1154 case PRODUCER: 1155 tgt.setValue(CapabilityStatement.DocumentMode.PRODUCER); 1156 break; 1157 case CONSUMER: 1158 tgt.setValue(CapabilityStatement.DocumentMode.CONSUMER); 1159 break; 1160 default: 1161 tgt.setValue(CapabilityStatement.DocumentMode.NULL); 1162 break; 1163 } 1164 } 1165 return tgt; 1166 } 1167}