final BTreePersistentIndexedCache<K, V> cache = getCache();
        // Use writeFile because the cache can internally recover from datafile
        // corruption, so we don't care at this level if it's corrupt
        fileAccess.writeFile(() -> cache.put(key, value));
    }

    @Override
    public void remove(final K key) {
        final BTreePersistentIndexedCache<K, V> cache = getCache();

        }
        int targetSize = cacheSizer.scaleCacheSize(maxEntriesToKeepInMemory);
        CacheDetails cacheDetails = getCache(cacheId, targetSize);
        return new InMemoryDecoratedCache<>(backingCache, cacheDetails.entries, cacheId, cacheDetails.lockState);
    }

    private CacheDetails getCache(final String cacheId, final int maxSize) {
        CacheDetails cacheDetails = caches.get(cacheId, () -> {

}

func ExampleUserCacheDir() {
	dir, dirErr := os.UserCacheDir()
	if dirErr == nil {
		dir = filepath.Join(dir, "ExampleUserCacheDir")
	}

	getCache := func(name string) ([]byte, error) {
		if dirErr != nil {
			return nil, &os.PathError{Op: "getCache", Path: name, Err: os.ErrNotExist}
		}
		return os.ReadFile(filepath.Join(dir, name))
	}

	var mkdirOnce sync.Once

import java.util.function.Supplier

class ArtifactCacheLockingAccessCoordinatorStub implements ArtifactCacheLockingAccessCoordinator {
    private final Map<String, IndexedCache<?, ?>> caches = [:]

    IndexedCache<?, ?> getCache(String cacheName) {
        caches[cacheName]
    }

    @Override
    <K, V> IndexedCache<K, V> createCache(String cacheName, Serializer<K> keySerializer, Serializer<V> valueSerializer) {

    @SuppressWarnings("unchecked")
    public static ModelCache newInstance(RepositorySystemSession session) {
        ConcurrentHashMap<Object, Supplier<?>> cache;
        RepositoryCache repositoryCache = session.getCache();
        if (repositoryCache == null) {
            cache = new ConcurrentHashMap<>();
        } else {
            cache = (ConcurrentHashMap<Object, Supplier<?>>)

    public static ModelCache newInstance(RepositorySystemSession session, boolean anew) {
        ConcurrentHashMap<Object, Supplier<?>> cache;
        RepositoryCache repositoryCache = session != null ? session.getCache() : null;
        if (repositoryCache == null) {
            return new DefaultModelCache(new ConcurrentHashMap<>());
        } else {
            if (anew) {
                cache = new ConcurrentHashMap<>();