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 org.apache.commons.compress.archivers.tar.TarArchiveEntry;
021import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
022import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream;
023import org.apache.commons.compress.compressors.gzip.GzipCompressorInputStream;
024import org.apache.commons.compress.compressors.gzip.GzipCompressorOutputStream;
025import org.hl7.fhir.convertors.advisors.impl.BaseAdvisor_30_40;
026import org.hl7.fhir.convertors.advisors.impl.BaseAdvisor_30_50;
027import org.hl7.fhir.convertors.context.ContextResourceLoaderFactory;
028import org.hl7.fhir.convertors.factory.VersionConvertorFactory_10_30;
029import org.hl7.fhir.convertors.factory.VersionConvertorFactory_10_40;
030import org.hl7.fhir.convertors.factory.VersionConvertorFactory_10_50;
031import org.hl7.fhir.convertors.factory.VersionConvertorFactory_14_30;
032import org.hl7.fhir.convertors.factory.VersionConvertorFactory_14_40;
033import org.hl7.fhir.convertors.factory.VersionConvertorFactory_14_50;
034import org.hl7.fhir.convertors.factory.VersionConvertorFactory_30_40;
035import org.hl7.fhir.convertors.factory.VersionConvertorFactory_30_50;
036import org.hl7.fhir.convertors.factory.VersionConvertorFactory_40_50;
037import org.hl7.fhir.convertors.loaders.loaderR5.NullLoaderKnowledgeProviderR5;
038import org.hl7.fhir.exceptions.DefinitionException;
039import org.hl7.fhir.r5.conformance.profile.ProfileUtilities;
040import org.hl7.fhir.r5.context.ContextUtilities;
041import org.hl7.fhir.r5.context.IContextResourceLoader;
042import org.hl7.fhir.r5.context.IWorkerContext;
043import org.hl7.fhir.r5.context.SimpleWorkerContext;
044import org.hl7.fhir.r5.model.CanonicalResource;
045import org.hl7.fhir.r5.model.CanonicalType;
046import org.hl7.fhir.r5.model.CodeSystem;
047import org.hl7.fhir.r5.model.ElementDefinition;
048import org.hl7.fhir.r5.model.ElementDefinition.TypeRefComponent;
049import org.hl7.fhir.r5.model.Enumeration;
050import org.hl7.fhir.r5.model.Enumerations.FHIRVersion;
051import org.hl7.fhir.r5.model.Enumerations.FHIRVersionEnumFactory;
052import org.hl7.fhir.r5.model.ImplementationGuide;
053import org.hl7.fhir.r5.model.Resource;
054import org.hl7.fhir.r5.model.StructureDefinition;
055import org.hl7.fhir.r5.model.ValueSet;
056import org.hl7.fhir.r5.model.ValueSet.ConceptSetComponent;
057import org.hl7.fhir.utilities.FileUtilities;
058import org.hl7.fhir.utilities.Utilities;
059import org.hl7.fhir.utilities.VersionUtilities;
060import org.hl7.fhir.utilities.filesystem.ManagedFileAccess;
061import org.hl7.fhir.utilities.json.model.JsonArray;
062import org.hl7.fhir.utilities.json.model.JsonObject;
063import org.hl7.fhir.utilities.json.parser.JsonParser;
064import org.hl7.fhir.utilities.npm.FilesystemPackageCacheManager;
065import org.hl7.fhir.utilities.npm.NpmPackage;
066import org.hl7.fhir.utilities.npm.NpmPackageIndexBuilder;
067
068public class NpmPackageVersionConverter {
069
070  private static final int BUFFER_SIZE = 1024;
071
072  private final String source;
073  private final String dest;
074  private final String version;
075  private final String vCode;
076  private final List<String> errors = new ArrayList<>();
077  private String currentVersion;
078  private String packageId;
079  private IWorkerContext context;
080  private Map<String, Resource> additionalResources = new HashMap<>();
081
082  private NpmPackage targetNpm;
083  private SimpleWorkerContext tctxt;
084  private ContextUtilities cu;
085
086  public NpmPackageVersionConverter(String source, String dest, String version, String packageId, IWorkerContext context) {
087    super();
088    this.source = source;
089    this.dest = dest;
090    this.vCode = version;
091    this.packageId = packageId;
092    this.version = VersionUtilities.versionFromCode(version);
093    this.context = context;
094    cu = new ContextUtilities(context);
095  }
096
097  public List<String> getErrors() {
098    return errors;
099  }
100
101  public void execute() throws IOException {
102    Map<String, byte[]> content = loadContentMap(ManagedFileAccess.inStream(source));
103
104    Map<String, byte[]> output = new HashMap<>();
105    output.put("package/package.json", convertPackage(content.get("package/package.json")));
106
107    output.put("package/other/spec.internals", convertSpec(content.get("package/other/spec.internals")));
108
109    for (Entry<String, byte[]> e : content.entrySet()) {
110      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")) {
111        byte[] cnv = e.getValue();
112        try {
113          JsonObject json = JsonParser.parseObject(e.getValue());
114          if (json.has("resourceType")) {
115            cnv = convertResource(e.getKey(), e.getValue());
116          }
117        } catch (Exception ex) {
118        }
119        if (cnv != null && cnv.length > 0) {
120          output.put(e.getKey(), cnv);
121        }
122      }
123    }
124    for (Resource res : additionalResources.values()) {
125      byte[] cnv = convertResource(res);
126      String fn = "package/"+res.fhirType()+"-"+res.getId()+".json";
127      if (output.containsKey(fn)) {
128        System.out.println("Duplicate resource "+fn);
129      } else {
130        output.put(fn, cnv);
131      }
132    }
133
134    TarArchiveOutputStream tar;
135    ByteArrayOutputStream OutputStream;
136    BufferedOutputStream bufferedOutputStream;
137    GzipCompressorOutputStream gzipOutputStream;
138
139    OutputStream = new ByteArrayOutputStream();
140    bufferedOutputStream = new BufferedOutputStream(OutputStream);
141    gzipOutputStream = new GzipCompressorOutputStream(bufferedOutputStream);
142    tar = new TarArchiveOutputStream(gzipOutputStream);
143
144
145    Map<String, NpmPackageIndexBuilder> indexers = new HashMap<>();
146    for (Entry<String, byte[]> e : output.entrySet()) {
147      String n = e.getKey().substring(0, e.getKey().lastIndexOf("/"));
148      String s = e.getKey().substring(n.length() + 1);
149      byte[] b = e.getValue();
150      NpmPackageIndexBuilder indexer = indexers.get(n);
151      if (indexer == null) {
152        indexer = new NpmPackageIndexBuilder();
153        indexer.start(Utilities.path("[tmp]", "tmp-"+UUID.randomUUID().toString()+".db"));
154        indexers.put(n, indexer);
155      }
156      indexer.seeFile(s, b);
157      if (!s.equals(".index.json") && !s.equals("package.json") && !s.equals(".index.db")) {
158        TarArchiveEntry entry = new TarArchiveEntry(e.getKey());
159        entry.setSize(b.length);
160        tar.putArchiveEntry(entry);
161        tar.write(b);
162        tar.closeArchiveEntry();
163      }
164    }
165    for (Entry<String, NpmPackageIndexBuilder> e : indexers.entrySet()) {
166      byte[] cnt = e.getValue().build().getBytes(StandardCharsets.UTF_8);
167      TarArchiveEntry entry = new TarArchiveEntry(e.getKey() + "/.index.json");
168      entry.setSize(cnt.length);
169      tar.putArchiveEntry(entry);
170      tar.write(cnt);
171      tar.closeArchiveEntry();
172      cnt = FileUtilities.fileToBytes(e.getValue().getDbFilename());
173      ManagedFileAccess.file(e.getValue().getDbFilename()).delete();
174      entry = new TarArchiveEntry(e.getKey() + "/.index.db");
175      entry.setSize(cnt.length);
176      tar.putArchiveEntry(entry);
177      tar.write(cnt);
178      tar.closeArchiveEntry();
179    }
180
181    byte[] cnt = output.get("package/package.json");
182    TarArchiveEntry entry = new TarArchiveEntry("package/package.json");
183    entry.setSize(cnt.length);
184    tar.putArchiveEntry(entry);
185    tar.write(cnt);
186    tar.closeArchiveEntry();
187
188    tar.finish();
189    tar.close();
190    gzipOutputStream.close();
191    bufferedOutputStream.close();
192    OutputStream.close();
193    byte[] b = OutputStream.toByteArray();
194    FileUtilities.bytesToFile(b, dest);
195  }
196
197  @Nonnull
198  protected Map<String, byte[]> loadContentMap(InputStream inputStream) throws IOException {
199    GzipCompressorInputStream gzipIn;
200    try {
201      gzipIn = new GzipCompressorInputStream(inputStream);
202    } catch (Exception e) {
203      throw new IOException("Error reading " + source + ": " + e.getMessage(), e);
204    }
205    Map<String, byte[]> content = new HashMap<>();
206
207    try (TarArchiveInputStream tarIn = new TarArchiveInputStream(gzipIn)) {
208      TarArchiveEntry entry;
209
210      while ((entry = (TarArchiveEntry) tarIn.getNextEntry()) != null) {
211        String n = entry.getName();
212        if (n.contains("..")) {
213          throw new RuntimeException("Entry with an illegal name: " + n);
214        }
215        if (!entry.isDirectory()) {
216          int count;
217          byte[] data = new byte[BUFFER_SIZE];
218          ByteArrayOutputStream fos = new ByteArrayOutputStream();
219          try (BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER_SIZE)) {
220            while ((count = tarIn.read(data, 0, BUFFER_SIZE)) != -1) {
221              dest.write(data, 0, count);
222            }
223          }
224          fos.close();
225          content.put(n, fos.toByteArray());
226        }
227      }
228    }
229    return content;
230  }
231
232  private byte[] convertPackage(byte[] cnt) throws IOException {
233    JsonObject json = JsonParser.parseObject(cnt);
234    currentVersion = json.getJsonArray("fhirVersions").get(0).asString();
235    String name = json.asString("name");
236    assert(packageId.equals(name + "." + vCode));
237    json.remove("name");
238    json.add("name", name + "." + vCode);
239    json.remove("fhirVersions");
240    json.remove("dependencies");
241    JsonArray fv = new JsonArray();
242    json.add("fhirVersions", fv);
243    fv.add(version);
244    JsonObject dep = new JsonObject();
245    json.add("dependencies", dep);
246    dep.add(VersionUtilities.packageForVersion(version), version);
247    return JsonParser.composeBytes(json);
248  }
249
250  private byte[] convertSpec(byte[] cnt) throws IOException {
251    JsonObject json = JsonParser.parseObject(cnt);
252    json.set("ig-version", version);
253    json.set("npm-name", packageId);
254    return JsonParser.composeBytes(json, true);
255  }
256
257  private byte[] convertResource(String n, byte[] cnt) {
258    try {
259      if (VersionUtilities.isR2Ver(currentVersion)) {
260        org.hl7.fhir.dstu2.model.Resource res = new org.hl7.fhir.dstu2.formats.JsonParser().parse(cnt);
261        convertResourceR2(res);
262        if (VersionUtilities.isR2Ver(version)) {
263          return new org.hl7.fhir.dstu2.formats.JsonParser().composeBytes(res);
264        } else if (VersionUtilities.isR2BVer(version)) {
265          return new org.hl7.fhir.dstu2016may.formats.JsonParser().composeBytes(VersionConvertorFactory_14_30.convertResource(VersionConvertorFactory_10_30.convertResource(res)));
266        } else if (VersionUtilities.isR3Ver(version)) {
267          return new org.hl7.fhir.dstu3.formats.JsonParser().composeBytes(VersionConvertorFactory_10_30.convertResource(res));
268        } else if (VersionUtilities.isR4Ver(version) || VersionUtilities.isR4BVer(version)) {
269          return new org.hl7.fhir.r4.formats.JsonParser().composeBytes(VersionConvertorFactory_10_40.convertResource(res));
270        } else if (VersionUtilities.isR5Plus(version)) {
271          return new org.hl7.fhir.r5.formats.JsonParser().composeBytes(VersionConvertorFactory_10_50.convertResource(res));
272        }
273      } else if (VersionUtilities.isR2BVer(currentVersion)) {
274        org.hl7.fhir.dstu2016may.model.Resource res = new org.hl7.fhir.dstu2016may.formats.JsonParser().parse(cnt);
275        convertResourceR2B(res);
276        if (VersionUtilities.isR2Ver(version)) {
277          return new org.hl7.fhir.dstu2.formats.JsonParser().composeBytes(VersionConvertorFactory_10_30.convertResource(VersionConvertorFactory_14_30.convertResource(res)));
278        } else if (VersionUtilities.isR2BVer(version)) {
279          return new org.hl7.fhir.dstu2016may.formats.JsonParser().composeBytes(res);
280        } else if (VersionUtilities.isR3Ver(version)) {
281          return new org.hl7.fhir.dstu3.formats.JsonParser().composeBytes(VersionConvertorFactory_14_30.convertResource(res));
282        } else if (VersionUtilities.isR4Ver(version) || VersionUtilities.isR4BVer(version)) {
283          return new org.hl7.fhir.r4.formats.JsonParser().composeBytes(VersionConvertorFactory_14_40.convertResource(res));
284        } else if (VersionUtilities.isR5Plus(version)) {
285          return new org.hl7.fhir.r5.formats.JsonParser().composeBytes(VersionConvertorFactory_14_50.convertResource(res));
286        }
287      } else if (VersionUtilities.isR3Ver(currentVersion)) {
288        org.hl7.fhir.dstu3.model.Resource res = new org.hl7.fhir.dstu3.formats.JsonParser().parse(cnt);
289        convertResourceR3(res);
290        if (VersionUtilities.isR2Ver(version)) {
291          return new org.hl7.fhir.dstu2.formats.JsonParser().composeBytes(VersionConvertorFactory_10_30.convertResource(res));
292        } else if (VersionUtilities.isR2BVer(version)) {
293          return new org.hl7.fhir.dstu2016may.formats.JsonParser().composeBytes(VersionConvertorFactory_14_30.convertResource(res));
294        } else if (VersionUtilities.isR3Ver(version)) {
295          return new org.hl7.fhir.dstu3.formats.JsonParser().composeBytes(res);
296        } else if (VersionUtilities.isR4Ver(version) || VersionUtilities.isR4BVer(version)) {
297          return new org.hl7.fhir.r4.formats.JsonParser().composeBytes(VersionConvertorFactory_30_40.convertResource(res));
298        } else if (VersionUtilities.isR5Plus(version)) {
299          return new org.hl7.fhir.r5.formats.JsonParser().composeBytes(VersionConvertorFactory_30_50.convertResource(res));
300        }
301      } else if (VersionUtilities.isR4Ver(currentVersion)) {
302        org.hl7.fhir.r4.model.Resource res = new org.hl7.fhir.r4.formats.JsonParser().parse(cnt);
303        convertResourceR4(res);
304        if (VersionUtilities.isR2Ver(version)) {
305          return new org.hl7.fhir.dstu2.formats.JsonParser().composeBytes(VersionConvertorFactory_10_40.convertResource(res, new PR2Handler()));
306        } else if (VersionUtilities.isR2BVer(version)) {
307          return new org.hl7.fhir.dstu2016may.formats.JsonParser().composeBytes(VersionConvertorFactory_14_40.convertResource(res));
308        } else if (VersionUtilities.isR3Ver(version)) {
309          return new org.hl7.fhir.dstu3.formats.JsonParser().composeBytes(VersionConvertorFactory_30_40.convertResource(res, new BaseAdvisor_30_40(false)));
310        } else if (VersionUtilities.isR4Ver(version) || VersionUtilities.isR4BVer(version)) {
311          return new org.hl7.fhir.r4.formats.JsonParser().composeBytes(res);
312        } else if (VersionUtilities.isR5Plus(version)) {
313          return new org.hl7.fhir.r5.formats.JsonParser().composeBytes(VersionConvertorFactory_40_50.convertResource(res));
314        }
315      } else if (VersionUtilities.isR4BVer(currentVersion)) {
316        org.hl7.fhir.r4.model.Resource res = new org.hl7.fhir.r4.formats.JsonParser().parse(cnt);
317        convertResourceR4B(res);
318        if (VersionUtilities.isR2Ver(version)) {
319          return new org.hl7.fhir.dstu2.formats.JsonParser().composeBytes(VersionConvertorFactory_10_40.convertResource(res, new PR2Handler()));
320        } else if (VersionUtilities.isR2BVer(version)) {
321          return new org.hl7.fhir.dstu2016may.formats.JsonParser().composeBytes(VersionConvertorFactory_14_40.convertResource(res));
322        } else if (VersionUtilities.isR3Ver(version)) {
323          return new org.hl7.fhir.dstu3.formats.JsonParser().composeBytes(VersionConvertorFactory_30_40.convertResource(res, new BaseAdvisor_30_40(false)));
324        } else if (VersionUtilities.isR4Ver(version) || VersionUtilities.isR4BVer(version)) {
325          return new org.hl7.fhir.r4.formats.JsonParser().composeBytes(res);
326        } else if (VersionUtilities.isR5Plus(version)) {
327          return new org.hl7.fhir.r5.formats.JsonParser().composeBytes(VersionConvertorFactory_40_50.convertResource(res));
328        }
329      } else if (VersionUtilities.isR5Plus(currentVersion)) {
330        org.hl7.fhir.r5.model.Resource res = new org.hl7.fhir.r5.formats.JsonParser().parse(cnt);
331        checkForCoreDependencies(res);
332        convertResourceR5(res);
333        if (VersionUtilities.isR2Ver(version)) {
334          return new org.hl7.fhir.dstu2.formats.JsonParser().composeBytes(VersionConvertorFactory_10_50.convertResource(res));
335        } else if (VersionUtilities.isR2BVer(version)) {
336          return new org.hl7.fhir.dstu2016may.formats.JsonParser().composeBytes(VersionConvertorFactory_14_50.convertResource(res));
337        } else if (VersionUtilities.isR3Ver(version)) {
338          return new org.hl7.fhir.dstu3.formats.JsonParser().composeBytes(VersionConvertorFactory_30_50.convertResource(res, new BaseAdvisor_30_50(false)));
339        } else if (VersionUtilities.isR4Ver(version) || VersionUtilities.isR4BVer(version)) {
340          return new org.hl7.fhir.r4.formats.JsonParser().composeBytes(VersionConvertorFactory_40_50.convertResource(res));
341        } else if (VersionUtilities.isR5Plus(version)) {
342          return new org.hl7.fhir.r5.formats.JsonParser().composeBytes(res);
343        }
344      }
345      throw new Error("Unknown version " + currentVersion + " -> " + version);
346    } catch (Exception ex) {
347      errors.add("Error converting " + n + ": " + ex.getMessage());
348
349      System.out.println("Error converting " + n + ": " + ex.getMessage());
350      ex.printStackTrace();
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}