private VersionCorrection getResolvedVersionCorrection() {
VersionCorrection versionCorrection = getExecutionOptions().getVersionCorrection();
if (!versionCorrection.containsLatest()) {
return versionCorrection;
}
return versionCorrection.withLatestFixed(Instant.now());
}
@SuppressWarnings("unchecked")
@Override
public Collection<V> get(
final ExternalIdBundle bundle, final VersionCorrection versionCorrection) {
ArgumentChecker.notNull(bundle, "bundle");
ArgumentChecker.notNull(versionCorrection, "versionCorrection");
if (versionCorrection.containsLatest()) {
Collection<V> results = getUnderlying().get(bundle, versionCorrection);
cacheItems(results);
return results;
}
final Pair<ExternalIdBundle, VersionCorrection> key = Pairs.of(bundle, versionCorrection);
final Element e = _eidToUidCache.get(key);
if (e != null) {
if (e.getObjectValue() instanceof Collection) {
final Collection<UniqueId> identifiers = (Collection<UniqueId>) e.getObjectValue();
if (identifiers.isEmpty()) {
return Collections.emptySet();
} else {
return get(identifiers).values();
}
}
}
final Collection<V> result = getUnderlying().get(bundle, versionCorrection);
if (result.isEmpty()) {
cacheIdentifiers(Collections.<UniqueId>emptyList(), key);
} else {
final List<UniqueId> uids = new ArrayList<UniqueId>(result.size());
for (final V item : result) {
uids.add(item.getUniqueId());
}
Collections.sort(uids);
cacheIdentifiers(uids, key);
cacheItems(result);
}
return result;
}
@Override
@SuppressWarnings("unchecked")
public Map<ExternalIdBundle, V> getSingle(
final Collection<ExternalIdBundle> bundles, final VersionCorrection versionCorrection) {
ArgumentChecker.notNull(bundles, "bundles");
ArgumentChecker.notNull(versionCorrection, "versionCorrection");
if (versionCorrection.containsLatest()) {
return getUnderlying().getSingle(bundles, versionCorrection);
}
final Map<ExternalIdBundle, V> results = Maps.newHashMapWithExpectedSize(bundles.size());
final Collection<ExternalIdBundle> misses = new ArrayList<ExternalIdBundle>(bundles.size());
final Map<ExternalIdBundle, Collection<UniqueId>> hits =
Maps.newHashMapWithExpectedSize(bundles.size());
final Set<UniqueId> lookup = Sets.newHashSetWithExpectedSize(bundles.size());
for (ExternalIdBundle bundle : bundles) {
final Pair<ExternalIdBundle, VersionCorrection> key = Pairs.of(bundle, versionCorrection);
final Element e = _eidToUidCache.get(key);
if (e != null) {
if (e.getObjectValue() instanceof List) {
final List<UniqueId> identifiers = (List<UniqueId>) e.getObjectValue();
lookup.addAll(identifiers);
hits.put(bundle, identifiers);
continue;
} else if (e.getObjectValue() instanceof UniqueId) {
final UniqueId identifier = (UniqueId) e.getObjectValue();
lookup.add(identifier);
hits.put(bundle, Collections.singleton(identifier));
continue;
}
}
misses.add(bundle);
}
if (!lookup.isEmpty()) {
final Map<UniqueId, V> underlying = getUnderlying().get(lookup);
for (Map.Entry<ExternalIdBundle, Collection<UniqueId>> hit : hits.entrySet()) {
final ExternalIdBundle bundle = hit.getKey();
for (UniqueId uid : hit.getValue()) {
final V result = underlying.get(uid);
if (result != null) {
results.put(bundle, result);
break;
}
}
}
}
if (!misses.isEmpty()) {
final Map<ExternalIdBundle, ? extends V> underlying =
getUnderlying().getSingle(misses, versionCorrection);
for (ExternalIdBundle miss : misses) {
final Pair<ExternalIdBundle, VersionCorrection> key = Pairs.of(miss, versionCorrection);
final V result = underlying.get(miss);
if (result == null) {
cacheIdentifiers(Collections.<UniqueId>emptyList(), key);
} else {
cacheIdentifiers(result.getUniqueId(), key);
cacheItem(result);
results.put(miss, result);
}
}
}
return results;
}
@SuppressWarnings("unchecked")
@Override
public Map<ExternalIdBundle, Collection<V>> getAll(
final Collection<ExternalIdBundle> bundles, VersionCorrection versionCorrection) {
ArgumentChecker.notNull(bundles, "bundles");
ArgumentChecker.notNull(versionCorrection, "versionCorrection");
if (versionCorrection.containsLatest()) {
return getUnderlying().getAll(bundles, versionCorrection);
}
final Map<ExternalIdBundle, Collection<V>> results =
Maps.newHashMapWithExpectedSize(bundles.size());
final Collection<ExternalIdBundle> misses = new ArrayList<ExternalIdBundle>(bundles.size());
final Map<ExternalIdBundle, Collection<UniqueId>> lookupBundles =
Maps.newHashMapWithExpectedSize(bundles.size());
final Set<UniqueId> lookupIds = Sets.newHashSetWithExpectedSize(bundles.size());
for (ExternalIdBundle bundle : bundles) {
final Pair<ExternalIdBundle, VersionCorrection> key = Pairs.of(bundle, versionCorrection);
final Element e = _eidToUidCache.get(key);
if (e != null) {
if (e.getObjectValue() instanceof Collection) {
final Collection<UniqueId> identifiers = (Collection<UniqueId>) e.getObjectValue();
if (identifiers.isEmpty()) {
results.put(bundle, Collections.<V>emptySet());
} else {
lookupBundles.put(bundle, identifiers);
lookupIds.addAll(identifiers);
}
continue;
}
}
misses.add(bundle);
}
if (!lookupIds.isEmpty()) {
final Map<UniqueId, V> underlying = get(lookupIds);
for (Map.Entry<ExternalIdBundle, Collection<UniqueId>> lookupBundle :
lookupBundles.entrySet()) {
final ArrayList<V> resultCollection = new ArrayList<V>(lookupBundle.getValue().size());
for (UniqueId uid : lookupBundle.getValue()) {
final V resultValue = underlying.get(uid);
if (resultValue != null) {
resultCollection.add(resultValue);
}
}
resultCollection.trimToSize();
results.put(lookupBundle.getKey(), resultCollection);
}
}
if (!misses.isEmpty()) {
final Map<ExternalIdBundle, Collection<V>> underlying =
getUnderlying().getAll(misses, versionCorrection);
for (ExternalIdBundle miss : misses) {
final Pair<ExternalIdBundle, VersionCorrection> key = Pairs.of(miss, versionCorrection);
final Collection<V> result = underlying.get(miss);
if ((result == null) || result.isEmpty()) {
cacheIdentifiers(Collections.<UniqueId>emptyList(), key);
} else {
final List<UniqueId> uids = new ArrayList<>(result.size());
for (final V item : result) {
uids.add(item.getUniqueId());
}
Collections.sort(uids);
cacheIdentifiers(uids, key);
cacheItems(result);
results.put(miss, result);
}
}
}
return results;
}