![](/hapi-fhir/images/logos/raccoon-forwards.png)
001package org.hl7.fhir.r5.context; 002 003import java.util.*; 004 005import org.hl7.fhir.exceptions.FHIRException; 006import org.hl7.fhir.r5.model.CanonicalResource; 007import org.hl7.fhir.r5.model.CodeSystem; 008import org.hl7.fhir.r5.model.Enumerations.CodeSystemContentMode; 009import org.hl7.fhir.r5.model.PackageInformation; 010import org.hl7.fhir.r5.model.StructureDefinition; 011import org.hl7.fhir.r5.terminologies.CodeSystemUtilities; 012import org.hl7.fhir.utilities.VersionUtilities; 013 014/** 015 * This manages a cached list of resources, and provides high speed access by URL / URL+version, and assumes that patch version doesn't matter for access 016 * note, though, that not all resources have semver versions 017 * 018 * @author graha 019 * 020 */ 021 022public class CanonicalResourceManager<T extends CanonicalResource> { 023 024 private final String[] INVALID_TERMINOLOGY_URLS = { 025 "http://snomed.info/sct", 026 "http://dicom.nema.org/resources/ontology/DCM", 027 "http://nucc.org/provider-taxonomy" 028 }; 029 030 public static abstract class CanonicalResourceProxy { 031 private String type; 032 private String id; 033 private String url; 034 private String version; 035 private String supplements; 036 private String derivation; 037 private CanonicalResource resource; 038 private boolean hacked; 039 private String content; 040 041 public CanonicalResourceProxy(String type, String id, String url, String version, String supplements, String derivation, String content) { 042 super(); 043 this.type = type; 044 this.id = id; 045 this.url = url; 046 this.version = version; 047 this.supplements = supplements; 048 this.content = content; 049 } 050 051 public String getType() { 052 return type; 053 } 054 055 public String getId() { 056 return id; 057 } 058 059 public String getUrl() { 060 return url; 061 } 062 063 public String getVersion() { 064 return version; 065 } 066 067 public boolean hasId() { 068 return id != null; 069 } 070 071 public boolean hasUrl() { 072 return url != null; 073 } 074 075 public boolean hasVersion() { 076 return version != null; 077 } 078 079 public String getSupplements() { 080 return supplements; 081 } 082 083 084 public String getContent() { 085 return content; 086 } 087 088 public String getDerivation() { 089 return derivation; 090 } 091 092 public void setDerivation(String derivation) { 093 this.derivation = derivation; 094 } 095 096 public CanonicalResource getResource() throws FHIRException { 097 if (resource == null) { 098 resource = loadResource(); 099 if (hacked) { 100 resource.setUrl(url).setVersion(version); 101 } 102 if (resource instanceof CodeSystem) { 103 CodeSystemUtilities.crossLinkCodeSystem((CodeSystem) resource); 104 } 105 } 106 return resource; 107 } 108 109 public void setResource(CanonicalResource resource) { 110 this.resource = resource; 111 } 112 113 public abstract CanonicalResource loadResource() throws FHIRException; 114 115 @Override 116 public String toString() { 117 return type+"/"+id+": "+url+"|"+version; 118 } 119 120 public void hack(String url, String version) { 121 this.url = url; 122 this.version = version; 123 this.hacked = true; 124 125 } 126 } 127 128 public static class CanonicalListSorter implements Comparator<CanonicalResource> { 129 130 @Override 131 public int compare(CanonicalResource arg0, CanonicalResource arg1) { 132 String u0 = arg0.getUrl(); 133 String u1 = arg1.getUrl(); 134 return u0.compareTo(u1); 135 } 136 } 137 138 public class CachedCanonicalResource<T1 extends CanonicalResource> { 139 private T1 resource; 140 private CanonicalResourceProxy proxy; 141 private PackageInformation packageInfo; 142 143 public CachedCanonicalResource(T1 resource, PackageInformation packageInfo) { 144 super(); 145 this.resource = resource; 146 this.packageInfo = packageInfo; 147 } 148 149 public CachedCanonicalResource(CanonicalResourceProxy proxy, PackageInformation packageInfo) { 150 super(); 151 this.proxy = proxy; 152 this.packageInfo = packageInfo; 153 } 154 155 public T1 getResource() { 156 if (resource == null) { 157 @SuppressWarnings("unchecked") 158 T1 res = (T1) proxy.getResource(); 159 if (res == null) { 160 throw new Error("Proxy loading a resource from "+packageInfo+" failed and returned null"); 161 } 162 synchronized (this) { 163 resource = res; 164 } 165 resource.setSourcePackage(packageInfo); 166 proxy = null; 167 } 168 return resource; 169 } 170 171 public PackageInformation getPackageInfo() { 172 return packageInfo; 173 } 174 public String getUrl() { 175 return resource != null ? resource.getUrl() : proxy.getUrl(); 176 } 177 public String getId() { 178 return resource != null ? resource.getId() : proxy.getId(); 179 } 180 public String getVersion() { 181 return resource != null ? resource.getVersion() : proxy.getVersion(); 182 } 183 public boolean hasVersion() { 184 return resource != null ? resource.hasVersion() : proxy.getVersion() != null; 185 } 186 public String getContent() { 187 if (resource != null && resource instanceof CodeSystem) { 188 CodeSystemContentMode cnt = ((CodeSystem) resource).getContent(); 189 return cnt == null ? null : cnt.toCode(); 190 } else if (proxy != null) { 191 return proxy.getContent(); 192 } else { 193 return null; 194 } 195 } 196 197 @Override 198 public String toString() { 199 return resource != null ? resource.fhirType()+"/"+resource.getId()+"["+resource.getUrl()+"|"+resource.getVersion()+"]" : proxy.toString(); 200 } 201 202 public String supplements() { 203 if (resource == null) { 204 return proxy.getSupplements(); 205 } else { 206 return resource instanceof CodeSystem ? ((CodeSystem) resource).getSupplements() : null; 207 } 208 } 209 210 public Object getDerivation() { 211 if (resource == null) { 212 return proxy.getDerivation(); 213 } else { 214 return resource instanceof StructureDefinition ? ((StructureDefinition) resource).getDerivationElement().primitiveValue() : null; 215 } 216 } 217 218 public void unload() { 219 if (proxy != null) { 220 resource = null; 221 } 222 } 223 } 224 225 public class MetadataResourceVersionComparator<T1 extends CachedCanonicalResource<T>> implements Comparator<T1> { 226 @Override 227 public int compare(T1 arg1, T1 arg2) { 228 String c1 = arg1.getContent(); 229 String c2 = arg2.getContent(); 230 if (c1 != null && c2 != null && !c1.equals(c2)) { 231 int i1 = orderOfContent(c1); 232 int i2 = orderOfContent(c2); 233 return Integer.compare(i1, i2); 234 } 235 String v1 = arg1.getVersion(); 236 String v2 = arg2.getVersion(); 237 if (v1 == null && v2 == null) { 238 return Integer.compare(list.indexOf(arg1), list.indexOf(arg2)); // retain original order 239 } else if (v1 == null) { 240 return -1; 241 } else if (v2 == null) { 242 return 1; 243 } else { 244 String mm1 = VersionUtilities.getMajMin(v1); 245 String mm2 = VersionUtilities.getMajMin(v2); 246 if (mm1 == null || mm2 == null) { 247 return v1.compareTo(v2); 248 } else { 249 return mm1.compareTo(mm2); 250 } 251 } 252 } 253 254 private int orderOfContent(String c) { 255 switch (c) { 256 case "not-present": return 1; 257 case "example": return 2; 258 case "fragment": return 3; 259 case "complete": return 5; 260 case "supplement": return 4; 261 } 262 return 0; 263 } 264 } 265 266 private boolean minimalMemory; 267 private boolean enforceUniqueId; 268 private List<CachedCanonicalResource<T>> list = new ArrayList<>(); 269 private Map<String, List<CachedCanonicalResource<T>>> listForId; 270 private Map<String, List<CachedCanonicalResource<T>>> listForUrl; 271 private Map<String, CachedCanonicalResource<T>> map; 272 private Map<String, List<CachedCanonicalResource<T>>> supplements; // general index based on CodeSystem.supplements 273 private String version; // for debugging purposes 274 275 276 public CanonicalResourceManager(boolean enforceUniqueId, boolean minimalMemory) { 277 super(); 278 this.enforceUniqueId = enforceUniqueId; 279 this.minimalMemory = minimalMemory; 280 list = new ArrayList<>(); 281 listForId = new HashMap<>(); 282 listForUrl = new HashMap<>(); 283 map = new HashMap<>(); 284 supplements = new HashMap<>(); // general index based on CodeSystem.supplements 285 } 286 287 288 public String getVersion() { 289 return version; 290 } 291 292 293 public void setVersion(String version) { 294 this.version = version; 295 } 296 297 298 public void copy(CanonicalResourceManager<T> source) { 299 list.clear(); 300 map.clear(); 301 list.addAll(source.list); 302 map.putAll(source.map); 303 } 304 305 public void register(CanonicalResourceProxy r, PackageInformation packgeInfo) { 306 if (!r.hasId()) { 307 throw new FHIRException("An id is required for a deferred load resource"); 308 } 309 CanonicalResourceManager<T>.CachedCanonicalResource<T> cr = new CachedCanonicalResource<T>(r, packgeInfo); 310 see(cr); 311 } 312 313 public void see(T r, PackageInformation packgeInfo) { 314 if (r != null) { 315 if (!r.hasId()) { 316 r.setId(UUID.randomUUID().toString()); 317 } 318 CanonicalResourceManager<T>.CachedCanonicalResource<T> cr = new CachedCanonicalResource<T>(r, packgeInfo); 319 see(cr); 320 } 321 } 322 323 public void see(CachedCanonicalResource<T> cr) { 324 // -- 1. exit conditions ----------------------------------------------------------------------------- 325 326 // ignore UTG NUCC erroneous code system 327 if (cr.getPackageInfo() != null 328 && cr.getPackageInfo().getId() != null 329 && cr.getPackageInfo().getId().startsWith("hl7.terminology") 330 && Arrays.stream(INVALID_TERMINOLOGY_URLS).anyMatch((it)->it.equals(cr.getUrl()))) { 331 return; 332 } 333 if (map.get(cr.getUrl()) != null && (cr.getPackageInfo() != null && cr.getPackageInfo().isExamplesPackage())) { 334 return; 335 } 336 337 // -- 2. preparation ----------------------------------------------------------------------------- 338 if (cr.resource != null && cr.getPackageInfo() != null) { 339 cr.resource.setSourcePackage(cr.getPackageInfo()); 340 } 341 342 // -- 3. deleting existing content --------------------------------------------------------------- 343 if (enforceUniqueId && map.containsKey(cr.getId())) { 344 drop(cr.getId()); 345 } 346 347 // special case logic for UTG support prior to version 5 348 if (cr.getPackageInfo() != null && cr.getPackageInfo().getId().startsWith("hl7.terminology")) { 349 List<CachedCanonicalResource<T>> toDrop = new ArrayList<>(); 350 for (CachedCanonicalResource<T> n : list) { 351 if (n.getUrl() != null && n.getUrl().equals(cr.getUrl()) && isBasePackage(n.getPackageInfo())) { 352 toDrop.add(n); 353 } 354 } 355 for (CachedCanonicalResource<T> n : toDrop) { 356 drop(n); 357 } 358 } 359// CachedCanonicalResource<T> existing = cr.hasVersion() ? map.get(cr.getUrl()+"|"+cr.getVersion()) : map.get(cr.getUrl()+"|#0"); 360// if (existing != null) { 361// drop(existing); // was list.remove(existing) 362// } 363 364 // -- 4. ok we add it to the list --------------------------------------------------------------- 365 if (!enforceUniqueId) { 366 if (!listForId.containsKey(cr.getId())) { 367 listForId.put(cr.getId(), new ArrayList<>()); 368 } 369 List<CachedCanonicalResource<T>> set = listForId.get(cr.getId()); 370 set.add(cr); 371 } 372 list.add(cr); 373 if (!listForUrl.containsKey(cr.getUrl())) { 374 listForUrl.put(cr.getUrl(), new ArrayList<>()); 375 } 376 addToSupplements(cr); 377 List<CachedCanonicalResource<T>> set = listForUrl.get(cr.getUrl()); 378 set.add(cr); 379 if (set.size() > 1) { 380 Collections.sort(set, new MetadataResourceVersionComparator<CachedCanonicalResource<T>>()); 381 } 382 383 // -- 4. add to the map all the ways --------------------------------------------------------------- 384 String pv = cr.getPackageInfo() != null ? cr.getPackageInfo().getVID() : null; 385 map.put(cr.getId(), cr); // we do this so we can drop by id - if not enforcing id, it's just the most recent resource with this id 386 map.put(cr.hasVersion() ? cr.getUrl()+"|"+cr.getVersion() : cr.getUrl()+"|#0", cr); 387 if (pv != null) { 388 map.put(pv+":"+(cr.hasVersion() ? cr.getUrl()+"|"+cr.getVersion() : cr.getUrl()+"|#0"), cr); 389 } 390 int ndx = set.indexOf(cr); 391 if (ndx == set.size()-1) { 392 map.put(cr.getUrl(), cr); 393 if (pv != null) { 394 map.put(pv+":"+cr.getUrl(), cr); 395 } 396 } 397 String mm = VersionUtilities.getMajMin(cr.getVersion()); 398 if (mm != null) { 399 if (pv != null) { 400 map.put(pv+":"+cr.getUrl()+"|"+mm, cr); 401 } 402 if (set.size() - 1 == ndx) { 403 map.put(cr.getUrl()+"|"+mm, cr); 404 } else { 405 for (int i = set.size() - 1; i > ndx; i--) { 406 if (mm.equals(VersionUtilities.getMajMin(set.get(i).getVersion()))) { 407 return; 408 } 409 map.put(cr.getUrl()+"|"+mm, cr); 410 } 411 } 412 } 413 } 414 415 private void addToSupplements(CanonicalResourceManager<T>.CachedCanonicalResource<T> cr) { 416 String surl = cr.supplements(); 417 if (surl != null) { 418 List<CanonicalResourceManager<T>.CachedCanonicalResource<T>> list = supplements.get(surl); 419 if (list == null) { 420 list = new ArrayList<>(); 421 supplements.put(surl, list); 422 } 423 list.add(cr); 424 } 425 } 426 427 428 public void drop(CachedCanonicalResource<T> cr) { 429 while (map.values().remove(cr)); 430 while (listForId.values().remove(cr)); 431 while (listForUrl.values().remove(cr)); 432 String surl = cr.supplements(); 433 if (surl != null) { 434 supplements.get(surl).remove(cr); 435 } 436 list.remove(cr); 437 List<CachedCanonicalResource<T>> set = listForUrl.get(cr.getUrl()); 438 if (set != null) { // it really should be 439 boolean last = set.indexOf(cr) == set.size()-1; 440 set.remove(cr); 441 if (!set.isEmpty()) { 442 CachedCanonicalResource<T> crl = set.get(set.size()-1); 443 if (last) { 444 map.put(crl.getUrl(), crl); 445 } 446 String mm = VersionUtilities.getMajMin(cr.getVersion()); 447 if (mm != null) { 448 for (int i = set.size()-1; i >= 0; i--) { 449 if (mm.equals(VersionUtilities.getMajMin(set.get(i).getVersion()))) { 450 map.put(cr.getUrl()+"|"+mm, set.get(i)); 451 break; 452 } 453 } 454 } 455 } 456 } 457 } 458 459 public void drop(String id) { 460 if (enforceUniqueId) { 461 CachedCanonicalResource<T> cr = map.get(id); 462 if (cr != null) { 463 drop(cr); 464 } 465 } else { 466 List<CachedCanonicalResource<T>> set = listForId.get(id); 467 if (set != null) { // it really should be 468 for (CachedCanonicalResource<T> i : set) { 469 drop(i); 470 } 471 } 472 } 473 } 474 475 private boolean isBasePackage(PackageInformation packageInfo) { 476 return packageInfo == null ? false : VersionUtilities.isCorePackage(packageInfo.getId()); 477 } 478 479 private void updateList(String url, String version) { 480 List<CachedCanonicalResource<T>> rl = new ArrayList<>(); 481 for (CachedCanonicalResource<T> t : list) { 482 if (url.equals(t.getUrl()) && !rl.contains(t)) { 483 rl.add(t); 484 } 485 } 486 if (rl.size() > 0) { 487 // sort by version as much as we are able 488 // the current is the latest 489 map.put(url, rl.get(rl.size()-1)); 490 // now, also, the latest for major/minor 491 if (version != null) { 492 CachedCanonicalResource<T> latest = null; 493 for (CachedCanonicalResource<T> t : rl) { 494 if (VersionUtilities.versionsCompatible(t.getVersion(), version)) { 495 latest = t; 496 } 497 } 498 if (latest != null) { // might be null if it's not using semver 499 String lv = VersionUtilities.getMajMin(latest.getVersion()); 500 if (lv != null && !lv.equals(version)) 501 map.put(url+"|"+lv, rl.get(rl.size()-1)); 502 } 503 } 504 } 505 } 506 507 508 public boolean has(String url) { 509 return map.containsKey(url); 510 } 511 512 public boolean has(String system, String version) { 513 if (map.containsKey(system+"|"+version)) 514 return true; 515 String mm = VersionUtilities.getMajMin(version); 516 if (mm != null) 517 return map.containsKey(system+"|"+mm); 518 else 519 return false; 520 } 521 522 public T get(String url) { 523 return map.containsKey(url) ? map.get(url).getResource() : null; 524 } 525 526 public T get(String system, String version) { 527 if (version == null) { 528 return get(system); 529 } else { 530 if (map.containsKey(system+"|"+version)) 531 return map.get(system+"|"+version).getResource(); 532 String mm = VersionUtilities.getMajMin(version); 533 if (mm != null && map.containsKey(system+"|"+mm)) 534 return map.get(system+"|"+mm).getResource(); 535 else 536 return null; 537 } 538 } 539 540 public List<T> getForUrl(String url) { 541 List<T> res = new ArrayList<>(); 542 List<CanonicalResourceManager<T>.CachedCanonicalResource<T>> list = listForUrl.get(url); 543 if (list != null) { 544 for (CanonicalResourceManager<T>.CachedCanonicalResource<T> t : list) { 545 res.add(t.getResource()); 546 } 547 } 548 return res; 549 } 550 551 /** 552 * This is asking for a packaged version aware resolution 553 * 554 * if we can resolve the reference in the package dependencies, we will. if we can't 555 * then we fall back to the non-package approach 556 * 557 * The context has to prepare the pvlist based on the original package 558 * @param url 559 * @param srcInfo 560 * @return 561 */ 562 public T get(String url, List<String> pvlist) { 563 for (String pv : pvlist) { 564 if (map.containsKey(pv+":"+url)) { 565 return map.get(pv+":"+url).getResource(); 566 } 567 } 568 return map.containsKey(url) ? map.get(url).getResource() : null; 569 } 570 571 public T get(String system, String version, List<String> pvlist) { 572 if (version == null) { 573 return get(system, pvlist); 574 } else { 575 for (String pv : pvlist) { 576 if (map.containsKey(pv+":"+system+"|"+version)) 577 return map.get(pv+":"+system+"|"+version).getResource(); 578 } 579 String mm = VersionUtilities.getMajMin(version); 580 if (mm != null && map.containsKey(system+"|"+mm)) 581 for (String pv : pvlist) { 582 if (map.containsKey(pv+":"+system+"|"+mm)) 583 return map.get(pv+":"+system+"|"+mm).getResource(); 584 } 585 586 if (map.containsKey(system+"|"+version)) 587 return map.get(system+"|"+version).getResource(); 588 if (mm != null && map.containsKey(system+"|"+mm)) 589 return map.get(system+"|"+mm).getResource(); 590 else 591 return null; 592 } 593 } 594 595 596 597 public PackageInformation getPackageInfo(String system, String version) { 598 if (version == null) { 599 return map.containsKey(system) ? map.get(system).getPackageInfo() : null; 600 } else { 601 if (map.containsKey(system+"|"+version)) 602 return map.get(system+"|"+version).getPackageInfo(); 603 String mm = VersionUtilities.getMajMin(version); 604 if (mm != null && map.containsKey(system+"|"+mm)) 605 return map.get(system+"|"+mm).getPackageInfo(); 606 else 607 return null; 608 } 609 } 610 611 612 613 614 public int size() { 615 return list.size(); 616 } 617 618 619 620 public void listAll(List<T> result) { 621 for (CachedCanonicalResource<T> t : list) { 622 result.add(t.getResource()); 623 } 624 } 625 626 public void listAllM(List<CanonicalResource> result) { 627 for (CachedCanonicalResource<T> t : list) { 628 result.add(t.getResource()); 629 } 630 } 631 632 public List<T> getSupplements(T cr) { 633 if (cr.hasSourcePackage()) { 634 List<String> pvl = new ArrayList<>(); 635 pvl.add(cr.getSourcePackage().getVID()); 636 return getSupplements(cr.getUrl(), cr.getVersion(), pvl); 637 } else { 638 return getSupplements(cr.getUrl(), cr.getVersion(), null); 639 } 640 } 641 642 public List<T> getSupplements(String url) { 643 return getSupplements(url, null, null); 644 } 645 646 public List<T> getSupplements(String url, String version) { 647 return getSupplements(url, version, null); 648 } 649 650 public List<T> getSupplements(String url, String version, List<String> pvlist) { 651 boolean possibleMatches = false; 652 List<T> res = new ArrayList<>(); 653 if (version != null) { 654 List<CanonicalResourceManager<T>.CachedCanonicalResource<T>> list = supplements.get(url+"|"+version); 655 if (list != null) { 656 for (CanonicalResourceManager<T>.CachedCanonicalResource<T> t : list) { 657 possibleMatches = true; 658 if (pvlist == null || pvlist.contains(t.getPackageInfo().getVID())) { 659 res.add(t.getResource()); 660 } 661 } 662 } 663 } 664 List<CanonicalResourceManager<T>.CachedCanonicalResource<T>> list = supplements.get(url); 665 if (list != null) { 666 for (CanonicalResourceManager<T>.CachedCanonicalResource<T> t : list) { 667 possibleMatches = true; 668 if (pvlist == null || t.getPackageInfo() == null || pvlist.contains(t.getPackageInfo().getVID())) { 669 res.add(t.getResource()); 670 } 671 } 672 } 673 if (res.isEmpty() && pvlist != null && possibleMatches) { 674 return getSupplements(url, version, null); 675 } else { 676 return res; 677 } 678 } 679 680 public void clear() { 681 list.clear(); 682 map.clear(); 683 684 } 685 686 public List<CachedCanonicalResource<T>> getCachedList() { 687 return list; 688 } 689 690 public List<T> getList() { 691 List<T> res = new ArrayList<>(); 692 for (CachedCanonicalResource<T> t : list) { 693 if (!res.contains(t.getResource())) { 694 res.add(t.getResource()); 695 } 696 } 697 return res; 698 } 699 700 public List<T> getSortedList() { 701 List<T> res = getList(); 702 Collections.sort(res, new CanonicalListSorter()); 703 return res; 704 } 705 706 public Set<String> keys() { 707 return map.keySet(); 708 } 709 710 public boolean isEnforceUniqueId() { 711 return enforceUniqueId; 712 } 713 714 715 public void unload() { 716 for (CachedCanonicalResource<T> t : list) { 717 t.unload(); 718 } 719 720 } 721 722 723}