Source code

001package org.hl7.fhir.convertors.misc;
002
003import java.io.BufferedOutputStream;
004import java.io.ByteArrayOutputStream;
005import java.io.File;
006import java.io.FileInputStream;
007import java.io.FileNotFoundException;
008import java.io.IOException;
009import java.io.InputStream;
010import java.nio.charset.StandardCharsets;
011import java.util.ArrayList;
012import java.util.HashMap;
013import java.util.List;
014import java.util.Map;
015import java.util.UUID;
016import java.util.Map.Entry;
017
018import javax.annotation.Nonnull;
019
020import lombok.extern.slf4j.Slf4j;
021import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
022import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
023import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream;
024import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream;
025import org.apache.commons.compress.compressors.gzip.GzipCompressorOutputStream;
026import org.hl7.fhir.convertors.advisors.impl.BaseAdvisor_30_40;
027import org.hl7.fhir.convertors.advisors.impl.BaseAdvisor_30_50;
028import org.hl7.fhir.convertors.context.ContextResourceLoaderFactory;
029import org.hl7.fhir.convertors.factory.VersionConvertorFactory_10_30;
030import org.hl7.fhir.convertors.factory.VersionConvertorFactory_10_40;
031import org.hl7.fhir.convertors.factory.VersionConvertorFactory_10_50;
032import org.hl7.fhir.convertors.factory.VersionConvertorFactory_14_30;
033import org.hl7.fhir.convertors.factory.VersionConvertorFactory_14_40;
034import org.hl7.fhir.convertors.factory.VersionConvertorFactory_14_50;
035import org.hl7.fhir.convertors.factory.VersionConvertorFactory_30_40;
036import org.hl7.fhir.convertors.factory.VersionConvertorFactory_30_50;
037import org.hl7.fhir.convertors.factory.VersionConvertorFactory_40_50;
038import org.hl7.fhir.convertors.loaders.loaderR5.NullLoaderKnowledgeProviderR5;
039import org.hl7.fhir.exceptions.DefinitionException;
040import org.hl7.fhir.r5.conformance.profile.ProfileUtilities;
041import org.hl7.fhir.r5.context.ContextUtilities;
042import org.hl7.fhir.r5.context.IContextResourceLoader;
043import org.hl7.fhir.r5.context.IWorkerContext;
044import org.hl7.fhir.r5.context.SimpleWorkerContext;
045import org.hl7.fhir.r5.model.CanonicalResource;
046import org.hl7.fhir.r5.model.CanonicalType;
047import org.hl7.fhir.r5.model.CodeSystem;
048import org.hl7.fhir.r5.model.ElementDefinition;
049import org.hl7.fhir.r5.model.ElementDefinition.TypeRefComponent;
050import org.hl7.fhir.r5.model.Enumeration;
051import org.hl7.fhir.r5.model.Enumerations.FHIRVersion;
052import org.hl7.fhir.r5.model.Enumerations.FHIRVersionEnumFactory;
053import org.hl7.fhir.r5.model.ImplementationGuide;
054import org.hl7.fhir.r5.model.Resource;
055import org.hl7.fhir.r5.model.StructureDefinition;
056import org.hl7.fhir.r5.model.ValueSet;
057import org.hl7.fhir.r5.model.ValueSet.ConceptSetComponent;
058import org.hl7.fhir.utilities.FileUtilities;
059import org.hl7.fhir.utilities.Utilities;
060import org.hl7.fhir.utilities.VersionUtilities;
061import org.hl7.fhir.utilities.filesystem.ManagedFileAccess;
062import org.hl7.fhir.utilities.json.model.JsonArray;
063import org.hl7.fhir.utilities.json.model.JsonObject;
064import org.hl7.fhir.utilities.json.parser.JsonParser;
065import org.hl7.fhir.utilities.npm.FilesystemPackageCacheManager;
066import org.hl7.fhir.utilities.npm.NpmPackage;
067import org.hl7.fhir.utilities.npm.NpmPackageIndexBuilder;
068
069@Slf4j
070public class NpmPackageVersionConverter {
071
072  private static final int BUFFER_SIZE = 1024;
073
074  private final String source;
075  private final String dest;
076  private final String version;
077  private final String vCode;
078  private final List<String> errors = new ArrayList<>();
079  private String currentVersion;
080  private String packageId;
081  private IWorkerContext context;
082  private Map<String, Resource> additionalResources = new HashMap<>();
083
084  private NpmPackage targetNpm;
085  private SimpleWorkerContext tctxt;
086  private ContextUtilities cu;
087
088  public NpmPackageVersionConverter(String source, String dest, String version, String packageId, IWorkerContext context) {
089    super();
090    this.source = source;
091    this.dest = dest;
092    this.vCode = version;
093    this.packageId = packageId;
094    this.version = VersionUtilities.versionFromCode(version);
095    this.context = context;
096    cu = new ContextUtilities(context);
097  }
098
099  public List<String> getErrors() {
100    return errors;
101  }
102
103  public void execute() throws IOException {
104    Map<String, byte[]> content = loadContentMap(ManagedFileAccess.inStream(source));
105
106    Map<String, byte[]> output = new HashMap<>();
107    output.put("package/package.json", convertPackage(content.get("package/package.json")));
108
109    output.put("package/other/spec.internals", convertSpec(content.get("package/other/spec.internals")));
110
111    for (Entry<String, byte[]> e : content.entrySet()) {
112      if (!e.getKey().equals("package/package.json") && !e.getKey().equals("package/other/spec.internals") && !e.getKey().endsWith("ig-r4.json") && !e.getKey().endsWith("ig-r4.jsonX")) {
113        byte[] cnv = e.getValue();
114        try {
115          JsonObject json = JsonParser.parseObject(e.getValue());
116          if (json.has("resourceType")) {
117            cnv = convertResource(e.getKey(), e.getValue());
118          }
119        } catch (Exception ex) {
120        }
121        if (cnv != null && cnv.length > 0) {
122          output.put(e.getKey(), cnv);
123        }
124      }
125    }
126    for (Resource res : additionalResources.values()) {
127      byte[] cnv = convertResource(res);
128      String fn = "package/"+res.fhirType()+"-"+res.getId()+".json";
129      if (output.containsKey(fn)) {
130        log.warn("Duplicate resource "+fn);
131      } else {
132        output.put(fn, cnv);
133      }
134    }
135
136    TarArchiveOutputStream tar;
137    ByteArrayOutputStream OutputStream;
138    BufferedOutputStream bufferedOutputStream;
139    GzipCompressorOutputStream gzipOutputStream;
140
141    OutputStream = new ByteArrayOutputStream();
142    bufferedOutputStream = new BufferedOutputStream(OutputStream);
143    gzipOutputStream = new GzipCompressorOutputStream(bufferedOutputStream);
144    tar = new TarArchiveOutputStream(gzipOutputStream);
145
146
147    Map<String, NpmPackageIndexBuilder> indexers = new HashMap<>();
148    for (Entry<String, byte[]> e : output.entrySet()) {
149      String n = e.getKey().substring(0, e.getKey().lastIndexOf("/"));
150      String s = e.getKey().substring(n.length() + 1);
151      byte[] b = e.getValue();
152      NpmPackageIndexBuilder indexer = indexers.get(n);
153      if (indexer == null) {
154        indexer = new NpmPackageIndexBuilder();
155        indexer.start(Utilities.path("[tmp]", "tmp-"+UUID.randomUUID().toString()+".db"));
156        indexers.put(n, indexer);
157      }
158      indexer.seeFile(s, b);
159      if (!s.equals(".index.json") && !s.equals("package.json") && !s.equals(".index.db")) {
160        TarArchiveEntry entry = new TarArchiveEntry(e.getKey());
161        entry.setSize(b.length);
162        tar.putArchiveEntry(entry);
163        tar.write(b);
164        tar.closeArchiveEntry();
165      }
166    }
167    for (Entry<String, NpmPackageIndexBuilder> e : indexers.entrySet()) {
168      byte[] cnt = e.getValue().build().getBytes(StandardCharsets.UTF_8);
169      TarArchiveEntry entry = new TarArchiveEntry(e.getKey() + "/.index.json");
170      entry.setSize(cnt.length);
171      tar.putArchiveEntry(entry);
172      tar.write(cnt);
173      tar.closeArchiveEntry();
174      cnt = FileUtilities.fileToBytes(e.getValue().getDbFilename());
175      ManagedFileAccess.file(e.getValue().getDbFilename()).delete();
176      entry = new TarArchiveEntry(e.getKey() + "/.index.db");
177      entry.setSize(cnt.length);
178      tar.putArchiveEntry(entry);
179      tar.write(cnt);
180      tar.closeArchiveEntry();
181    }
182
183    byte[] cnt = output.get("package/package.json");
184    TarArchiveEntry entry = new TarArchiveEntry("package/package.json");
185    entry.setSize(cnt.length);
186    tar.putArchiveEntry(entry);
187    tar.write(cnt);
188    tar.closeArchiveEntry();
189
190    tar.finish();
191    tar.close();
192    gzipOutputStream.close();
193    bufferedOutputStream.close();
194    OutputStream.close();
195    byte[] b = OutputStream.toByteArray();
196    FileUtilities.bytesToFile(b, dest);
197  }
198
199  @Nonnull
200  protected Map<String, byte[]> loadContentMap(InputStream inputStream) throws IOException {
201    GzipCompressorInputStream gzipIn;
202    try {
203      gzipIn = new GzipCompressorInputStream(inputStream);
204    } catch (Exception e) {
205      throw new IOException("Error reading " + source + ": " + e.getMessage(), e);
206    }
207    Map<String, byte[]> content = new HashMap<>();
208
209    try (TarArchiveInputStream tarIn = new TarArchiveInputStream(gzipIn)) {
210      TarArchiveEntry entry;
211
212      while ((entry = (TarArchiveEntry) tarIn.getNextEntry()) != null) {
213        String n = entry.getName();
214        if (n.contains("..")) {
215          throw new RuntimeException("Entry with an illegal name: " + n);
216        }
217        if (!entry.isDirectory()) {
218          int count;
219          byte[] data = new byte[BUFFER_SIZE];
220          ByteArrayOutputStream fos = new ByteArrayOutputStream();
221          try (BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER_SIZE)) {
222            while ((count = tarIn.read(data, 0, BUFFER_SIZE)) != -1) {
223              dest.write(data, 0, count);
224            }
225          }
226          fos.close();
227          content.put(n, fos.toByteArray());
228        }
229      }
230    }
231    return content;
232  }
233
234  private byte[] convertPackage(byte[] cnt) throws IOException {
235    JsonObject json = JsonParser.parseObject(cnt);
236    currentVersion = json.getJsonArray("fhirVersions").get(0).asString();
237    String name = json.asString("name");
238    assert(packageId.equals(name + "." + vCode));
239    json.remove("name");
240    json.add("name", name + "." + vCode);
241    json.remove("fhirVersions");
242    json.remove("dependencies");
243    JsonArray fv = new JsonArray();
244    json.add("fhirVersions", fv);
245    fv.add(version);
246    JsonObject dep = new JsonObject();
247    json.add("dependencies", dep);
248    dep.add(VersionUtilities.packageForVersion(version), version);
249    return JsonParser.composeBytes(json);
250  }
251
252  private byte[] convertSpec(byte[] cnt) throws IOException {
253    JsonObject json = JsonParser.parseObject(cnt);
254    json.set("ig-version", version);
255    json.set("npm-name", packageId);
256    return JsonParser.composeBytes(json, true);
257  }
258
259  private byte[] convertResource(String n, byte[] cnt) {
260    try {
261      if (VersionUtilities.isR2Ver(currentVersion)) {
262        org.hl7.fhir.dstu2.model.Resource res = new org.hl7.fhir.dstu2.formats.JsonParser().parse(cnt);
263        convertResourceR2(res);
264        if (VersionUtilities.isR2Ver(version)) {
265          return new org.hl7.fhir.dstu2.formats.JsonParser().composeBytes(res);
266        } else if (VersionUtilities.isR2BVer(version)) {
267          return new org.hl7.fhir.dstu2016may.formats.JsonParser().composeBytes(VersionConvertorFactory_14_30.convertResource(VersionConvertorFactory_10_30.convertResource(res)));
268        } else if (VersionUtilities.isR3Ver(version)) {
269          return new org.hl7.fhir.dstu3.formats.JsonParser().composeBytes(VersionConvertorFactory_10_30.convertResource(res));
270        } else if (VersionUtilities.isR4Ver(version) || VersionUtilities.isR4BVer(version)) {
271          return new org.hl7.fhir.r4.formats.JsonParser().composeBytes(VersionConvertorFactory_10_40.convertResource(res));
272        } else if (VersionUtilities.isR5Plus(version)) {
273          return new org.hl7.fhir.r5.formats.JsonParser().composeBytes(VersionConvertorFactory_10_50.convertResource(res));
274        }
275      } else if (VersionUtilities.isR2BVer(currentVersion)) {
276        org.hl7.fhir.dstu2016may.model.Resource res = new org.hl7.fhir.dstu2016may.formats.JsonParser().parse(cnt);
277        convertResourceR2B(res);
278        if (VersionUtilities.isR2Ver(version)) {
279          return new org.hl7.fhir.dstu2.formats.JsonParser().composeBytes(VersionConvertorFactory_10_30.convertResource(VersionConvertorFactory_14_30.convertResource(res)));
280        } else if (VersionUtilities.isR2BVer(version)) {
281          return new org.hl7.fhir.dstu2016may.formats.JsonParser().composeBytes(res);
282        } else if (VersionUtilities.isR3Ver(version)) {
283          return new org.hl7.fhir.dstu3.formats.JsonParser().composeBytes(VersionConvertorFactory_14_30.convertResource(res));
284        } else if (VersionUtilities.isR4Ver(version) || VersionUtilities.isR4BVer(version)) {
285          return new org.hl7.fhir.r4.formats.JsonParser().composeBytes(VersionConvertorFactory_14_40.convertResource(res));
286        } else if (VersionUtilities.isR5Plus(version)) {
287          return new org.hl7.fhir.r5.formats.JsonParser().composeBytes(VersionConvertorFactory_14_50.convertResource(res));
288        }
289      } else if (VersionUtilities.isR3Ver(currentVersion)) {
290        org.hl7.fhir.dstu3.model.Resource res = new org.hl7.fhir.dstu3.formats.JsonParser().parse(cnt);
291        convertResourceR3(res);
292        if (VersionUtilities.isR2Ver(version)) {
293          return new org.hl7.fhir.dstu2.formats.JsonParser().composeBytes(VersionConvertorFactory_10_30.convertResource(res));
294        } else if (VersionUtilities.isR2BVer(version)) {
295          return new org.hl7.fhir.dstu2016may.formats.JsonParser().composeBytes(VersionConvertorFactory_14_30.convertResource(res));
296        } else if (VersionUtilities.isR3Ver(version)) {
297          return new org.hl7.fhir.dstu3.formats.JsonParser().composeBytes(res);
298        } else if (VersionUtilities.isR4Ver(version) || VersionUtilities.isR4BVer(version)) {
299          return new org.hl7.fhir.r4.formats.JsonParser().composeBytes(VersionConvertorFactory_30_40.convertResource(res));
300        } else if (VersionUtilities.isR5Plus(version)) {
301          return new org.hl7.fhir.r5.formats.JsonParser().composeBytes(VersionConvertorFactory_30_50.convertResource(res));
302        }
303      } else if (VersionUtilities.isR4Ver(currentVersion)) {
304        org.hl7.fhir.r4.model.Resource res = new org.hl7.fhir.r4.formats.JsonParser().parse(cnt);
305        convertResourceR4(res);
306        if (VersionUtilities.isR2Ver(version)) {
307          return new org.hl7.fhir.dstu2.formats.JsonParser().composeBytes(VersionConvertorFactory_10_40.convertResource(res, new PR2Handler()));
308        } else if (VersionUtilities.isR2BVer(version)) {
309          return new org.hl7.fhir.dstu2016may.formats.JsonParser().composeBytes(VersionConvertorFactory_14_40.convertResource(res));
310        } else if (VersionUtilities.isR3Ver(version)) {
311          return new org.hl7.fhir.dstu3.formats.JsonParser().composeBytes(VersionConvertorFactory_30_40.convertResource(res, new BaseAdvisor_30_40(false)));
312        } else if (VersionUtilities.isR4Ver(version) || VersionUtilities.isR4BVer(version)) {
313          return new org.hl7.fhir.r4.formats.JsonParser().composeBytes(res);
314        } else if (VersionUtilities.isR5Plus(version)) {
315          return new org.hl7.fhir.r5.formats.JsonParser().composeBytes(VersionConvertorFactory_40_50.convertResource(res));
316        }
317      } else if (VersionUtilities.isR4BVer(currentVersion)) {
318        org.hl7.fhir.r4.model.Resource res = new org.hl7.fhir.r4.formats.JsonParser().parse(cnt);
319        convertResourceR4B(res);
320        if (VersionUtilities.isR2Ver(version)) {
321          return new org.hl7.fhir.dstu2.formats.JsonParser().composeBytes(VersionConvertorFactory_10_40.convertResource(res, new PR2Handler()));
322        } else if (VersionUtilities.isR2BVer(version)) {
323          return new org.hl7.fhir.dstu2016may.formats.JsonParser().composeBytes(VersionConvertorFactory_14_40.convertResource(res));
324        } else if (VersionUtilities.isR3Ver(version)) {
325          return new org.hl7.fhir.dstu3.formats.JsonParser().composeBytes(VersionConvertorFactory_30_40.convertResource(res, new BaseAdvisor_30_40(false)));
326        } else if (VersionUtilities.isR4Ver(version) || VersionUtilities.isR4BVer(version)) {
327          return new org.hl7.fhir.r4.formats.JsonParser().composeBytes(res);
328        } else if (VersionUtilities.isR5Plus(version)) {
329          return new org.hl7.fhir.r5.formats.JsonParser().composeBytes(VersionConvertorFactory_40_50.convertResource(res));
330        }
331      } else if (VersionUtilities.isR5Plus(currentVersion)) {
332        org.hl7.fhir.r5.model.Resource res = new org.hl7.fhir.r5.formats.JsonParser().parse(cnt);
333        checkForCoreDependencies(res);
334        convertResourceR5(res);
335        if (VersionUtilities.isR2Ver(version)) {
336          return new org.hl7.fhir.dstu2.formats.JsonParser().composeBytes(VersionConvertorFactory_10_50.convertResource(res));
337        } else if (VersionUtilities.isR2BVer(version)) {
338          return new org.hl7.fhir.dstu2016may.formats.JsonParser().composeBytes(VersionConvertorFactory_14_50.convertResource(res));
339        } else if (VersionUtilities.isR3Ver(version)) {
340          return new org.hl7.fhir.dstu3.formats.JsonParser().composeBytes(VersionConvertorFactory_30_50.convertResource(res, new BaseAdvisor_30_50(false)));
341        } else if (VersionUtilities.isR4Ver(version) || VersionUtilities.isR4BVer(version)) {
342          return new org.hl7.fhir.r4.formats.JsonParser().composeBytes(VersionConvertorFactory_40_50.convertResource(res));
343        } else if (VersionUtilities.isR5Plus(version)) {
344          return new org.hl7.fhir.r5.formats.JsonParser().composeBytes(res);
345        }
346      }
347      throw new Error("Unknown version " + currentVersion + " -> " + version);
348    } catch (Exception ex) {
349      errors.add("Error converting " + n + ": " + ex.getMessage());
350      log.error("Error converting " + n + ": " + ex.getMessage(), ex);
351      return null;
352    }
353  }
354  private byte[] convertResource(Resource res) {
355    try {
356      convertResourceR5(res);
357      if (VersionUtilities.isR2Ver(version)) {
358        return new org.hl7.fhir.dstu2.formats.JsonParser().composeBytes(VersionConvertorFactory_10_50.convertResource(res));
359      } else if (VersionUtilities.isR2BVer(version)) {
360        return new org.hl7.fhir.dstu2016may.formats.JsonParser().composeBytes(VersionConvertorFactory_14_50.convertResource(res));
361      } else if (VersionUtilities.isR3Ver(version)) {
362        return new org.hl7.fhir.dstu3.formats.JsonParser().composeBytes(VersionConvertorFactory_30_50.convertResource(res, new BaseAdvisor_30_50(false)));
363      } else if (VersionUtilities.isR4Ver(version) || VersionUtilities.isR4BVer(version)) {
364        return new org.hl7.fhir.r4.formats.JsonParser().composeBytes(VersionConvertorFactory_40_50.convertResource(res));
365      } else if (VersionUtilities.isR5Plus(version)) {
366        return new org.hl7.fhir.r5.formats.JsonParser().composeBytes(res);
367      }
368      throw new Error("Unknown version " + currentVersion + " -> " + version);
369    } catch (Exception ex) {
370      errors.add("Error converting " + res.fhirType()+"/"+res.getId() + ": " + ex.getMessage());
371      return null;
372    }
373  }
374
375
376  private void checkForCoreDependencies(Resource res) throws IOException {
377    if (res instanceof StructureDefinition) {
378      checkForCoreDependenciesSD((StructureDefinition) res);
379    }
380    if (res instanceof ValueSet) {
381      checkForCoreDependenciesVS((ValueSet) res);
382    }    
383  }
384
385  private void checkForCoreDependenciesSD(StructureDefinition sd) throws IOException {
386    for (ElementDefinition ed : sd.getSnapshot().getElement()) {
387      if (ed.hasBinding() && ed.getBinding().hasValueSet()) {
388        ValueSet vs = context.fetchResource(ValueSet.class, ed.getBinding().getValueSet());
389        if (vs != null) {
390          checkForCoreDependenciesVS(vs);
391        }
392      }
393    }
394  }
395
396  private void checkForCoreDependenciesVS(ValueSet valueSet) throws IOException {
397    if (isCoreResource(valueSet)) {
398      if (!inTargetCore(valueSet)) {
399        additionalResources.put(valueSet.getUrl(), valueSet);
400      }
401    }
402    for (ConceptSetComponent inc : valueSet.getCompose().getInclude()) {
403      for (CanonicalType c : inc.getValueSet()) {
404        ValueSet vs = context.fetchResource(ValueSet.class, c.getValue());
405        if (vs != null) {
406          checkForCoreDependenciesVS(vs);
407        }
408      }
409      if (inc.hasSystem()) {
410        CodeSystem cs = context.fetchResource(CodeSystem.class, inc.getSystem(), inc.getVersion());
411        if (cs != null) {
412          checkForCoreDependenciesCS(cs);
413        }
414      }
415    }    
416  }
417
418  private void checkForCoreDependenciesCS(CodeSystem cs) throws IOException {
419    if (isCoreResource(cs)) {
420      if (!inTargetCore(cs)) {
421        additionalResources.put(cs.getUrl(), cs);
422      }
423    }
424  }
425
426  private boolean inTargetCore(CanonicalResource cr) throws IOException {
427    boolean res = targetNpm.hasCanonical(cr.getUrl());
428    return res;
429  }
430
431  private boolean isCoreResource(CanonicalResource cr) {
432    return cr.hasSourcePackage() && Utilities.existsInList(cr.getSourcePackage().getId(), "hl7.fhir.r5.core", "hl7.fhir.r4.core");
433  }
434
435  private void convertResourceR2(org.hl7.fhir.dstu2.model.Resource res) {
436    if (res instanceof org.hl7.fhir.dstu2.model.ImplementationGuide) {
437      org.hl7.fhir.dstu2.model.ImplementationGuide ig = (org.hl7.fhir.dstu2.model.ImplementationGuide) res;
438      ig.setFhirVersion(version);
439    } 
440    if (res instanceof org.hl7.fhir.dstu2.model.StructureDefinition) {
441      org.hl7.fhir.dstu2.model.StructureDefinition sd = (org.hl7.fhir.dstu2.model.StructureDefinition) res;
442      sd.setFhirVersion(version);
443    }
444  }
445
446  private void convertResourceR2B(org.hl7.fhir.dstu2016may.model.Resource res) {
447    if (res instanceof org.hl7.fhir.dstu2016may.model.ImplementationGuide) {
448      org.hl7.fhir.dstu2016may.model.ImplementationGuide ig = (org.hl7.fhir.dstu2016may.model.ImplementationGuide) res;
449      ig.setFhirVersion(version);
450    } 
451    if (res instanceof org.hl7.fhir.dstu2016may.model.StructureDefinition) {
452      org.hl7.fhir.dstu2016may.model.StructureDefinition sd = (org.hl7.fhir.dstu2016may.model.StructureDefinition) res;
453      sd.setFhirVersion(version);
454    }
455  }
456
457  private void convertResourceR3(org.hl7.fhir.dstu3.model.Resource res) {
458    if (res instanceof org.hl7.fhir.dstu3.model.ImplementationGuide) {
459      org.hl7.fhir.dstu3.model.ImplementationGuide ig = (org.hl7.fhir.dstu3.model.ImplementationGuide) res;
460      ig.setFhirVersion(version);
461    }    
462    if (res instanceof org.hl7.fhir.dstu3.model.StructureDefinition) {
463      org.hl7.fhir.dstu3.model.StructureDefinition sd = (org.hl7.fhir.dstu3.model.StructureDefinition) res;
464      sd.setFhirVersion(version);
465    }
466  }
467
468  private void convertResourceR4(org.hl7.fhir.r4.model.Resource res) {
469    if (res instanceof org.hl7.fhir.r4.model.ImplementationGuide) {
470      org.hl7.fhir.r4.model.ImplementationGuide ig = (org.hl7.fhir.r4.model.ImplementationGuide) res;
471      ig.getFhirVersion().clear();
472      ig.getFhirVersion().add(new org.hl7.fhir.r4.model.Enumeration<>(new org.hl7.fhir.r4.model.Enumerations.FHIRVersionEnumFactory(), version));
473      ig.setPackageId(packageId);
474    }
475    if (res instanceof org.hl7.fhir.r4.model.StructureDefinition) {
476      org.hl7.fhir.r4.model.StructureDefinition sd = (org.hl7.fhir.r4.model.StructureDefinition) res;
477      sd.setFhirVersion(org.hl7.fhir.r4.model.Enumerations.FHIRVersion.fromCode(version));
478    }
479  }
480
481  private void convertResourceR4B(org.hl7.fhir.r4.model.Resource res) {
482    if (res instanceof org.hl7.fhir.r4.model.ImplementationGuide) {
483      org.hl7.fhir.r4.model.ImplementationGuide ig = (org.hl7.fhir.r4.model.ImplementationGuide) res;
484      ig.getFhirVersion().clear();
485      ig.getFhirVersion().add(new org.hl7.fhir.r4.model.Enumeration<>(new org.hl7.fhir.r4.model.Enumerations.FHIRVersionEnumFactory(), version));
486      ig.setPackageId(packageId);
487    }
488    if (res instanceof org.hl7.fhir.r4.model.StructureDefinition) {
489      org.hl7.fhir.r4.model.StructureDefinition sd = (org.hl7.fhir.r4.model.StructureDefinition) res;
490      sd.setFhirVersion(org.hl7.fhir.r4.model.Enumerations.FHIRVersion.fromCode(version));
491    }
492  }
493
494  private void convertResourceR5(Resource res) {
495    if (res instanceof ImplementationGuide) {
496      ImplementationGuide ig = (ImplementationGuide) res;
497      ig.getFhirVersion().clear();
498      ig.getFhirVersion().add(new Enumeration<>(new FHIRVersionEnumFactory(), version));
499      ig.setPackageId(packageId);
500    }
501    if (res instanceof StructureDefinition) {
502      StructureDefinition sd = (StructureDefinition) res;
503      sd.setFhirVersion(FHIRVersion.fromCode(version));
504    }
505  }
506
507}