keycloakjar.com.github.benmanes.caffeine.cache.LocalManualCache Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of camunda-bpm-identity-keycloak-all Show documentation
Show all versions of camunda-bpm-identity-keycloak-all Show documentation
Camunda Keycloak Identity Provider Plugin including all transitive dependencies
The newest version!
/*
* Copyright 2015 Ben Manes. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.github.benmanes.caffeine.cache;
import static java.util.Objects.requireNonNull;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletionException;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Function;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import com.github.benmanes.caffeine.cache.stats.CacheStats;
/**
* This class provides a skeletal implementation of the {@link Cache} interface to minimize the
* effort required to implement a {@link LocalCache}.
*
* @author [email protected] (Ben Manes)
*/
interface LocalManualCache extends Cache {
/** Returns the backing {@link LocalCache} data store. */
LocalCache cache();
@Override
default long estimatedSize() {
return cache().estimatedSize();
}
@Override
default void cleanUp() {
cache().cleanUp();
}
@Override
default @Nullable V getIfPresent(Object key) {
return cache().getIfPresent(key, /* recordStats */ true);
}
@Override
default @Nullable V get(K key, Function mappingFunction) {
return cache().computeIfAbsent(key, mappingFunction);
}
@Override
default Map getAllPresent(Iterable keys) {
return cache().getAllPresent(keys);
}
@Override
default Map getAll(Iterable keys,
Function, Map> mappingFunction) {
requireNonNull(mappingFunction);
Set keysToLoad = new LinkedHashSet<>();
Map found = cache().getAllPresent(keys);
Map result = new LinkedHashMap<>(found.size());
for (K key : keys) {
V value = found.get(key);
if (value == null) {
keysToLoad.add(key);
}
result.put(key, value);
}
if (keysToLoad.isEmpty()) {
return found;
}
bulkLoad(keysToLoad, result, mappingFunction);
return Collections.unmodifiableMap(result);
}
/**
* Performs a non-blocking bulk load of the missing keys. Any missing entry that materializes
* during the load are replaced when the loaded entries are inserted into the cache.
*/
default void bulkLoad(Set keysToLoad, Map result,
Function, @NonNull Map> mappingFunction) {
boolean success = false;
long startTime = cache().statsTicker().read();
try {
Map loaded = mappingFunction.apply(keysToLoad);
loaded.forEach((key, value) ->
cache().put(key, value, /* notifyWriter */ false));
for (K key : keysToLoad) {
V value = loaded.get(key);
if (value == null) {
result.remove(key);
} else {
result.put(key, value);
}
}
success = !loaded.isEmpty();
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new CompletionException(e);
} finally {
long loadTime = cache().statsTicker().read() - startTime;
if (success) {
cache().statsCounter().recordLoadSuccess(loadTime);
} else {
cache().statsCounter().recordLoadFailure(loadTime);
}
}
}
@Override
default void put(K key, V value) {
cache().put(key, value);
}
@Override
default void putAll(Map map) {
cache().putAll(map);
}
@Override
default void invalidate(Object key) {
cache().remove(key);
}
@Override
default void invalidateAll(Iterable keys) {
cache().invalidateAll(keys);
}
@Override
default void invalidateAll() {
cache().clear();
}
@Override
default CacheStats stats() {
return cache().statsCounter().snapshot();
}
@Override
default ConcurrentMap asMap() {
return cache();
}
}