private final VcsVersionSelectionCache inMemoryCache;
    private final VcsVersionWorkingDirResolver delegate;

    public OncePerBuildInvocationVcsVersionWorkingDirResolver(VcsVersionSelectionCache inMemoryCache, VcsVersionWorkingDirResolver delegate) {
        this.inMemoryCache = inMemoryCache;
        this.delegate = delegate;
    }

    @Nullable
    @Override

    }

    @Override
    protected CachedMetadata get(ModuleComponentAtRepositoryKey key) {
        CachedMetadata metadata = inMemoryCache.get(key);
        if (metadata == null && delegate != null) {
            metadata = delegate.get(key);
            if (metadata != null) {
                inMemoryCache.put(key, metadata);
            }
        }
        return metadata;
    }

    @Override

        this.inMemoryCache = inMemoryCache;
        this.cacheId = cacheId;
        this.fileLockStateReference = fileLockStateReference;
    }

    @Override
    public String toString() {
        return "{in-memory-cache cache: " + delegate + "}";
    }

    @Override
    public V get(final K key) {
        Object value;
        try {
            value = inMemoryCache.get(key, () -> {
                Object out = delegate.get(key);

    private final VersionParser versionParser;
    private final VcsVersionSelectionCache inMemoryCache;
    private final PersistentVcsMetadataCache persistentCache;

    public DefaultVcsVersionWorkingDirResolver(VersionSelectorScheme versionSelectorScheme, VersionComparator versionComparator, VersionParser versionParser, VcsVersionSelectionCache inMemoryCache, PersistentVcsMetadataCache persistentCache) {

        if (cachedArtifact == null && delegate != null) {
            cachedArtifact = delegate.lookup(key);
            if (cachedArtifact != null) {
                inMemoryCache.put(key, cachedArtifact);
            }
        }
        return cachedArtifact;
    }

    @Override
    public void clear(ArtifactAtRepositoryKey key) {
        inMemoryCache.remove(key);

        GFileUtils.mkdirs(cacheDir);
        InMemoryCache cache = new InMemoryCache(cacheDir, displayName, cacheCleanupStrategy != null ? cacheCleanupStrategy.getCleanupAction() : null);
        if (initializer != null) {
            initializer.accept(cache);
        }
        return cache;
    }

    public PersistentCache open(File cacheDir, String displayName) {
        return new InMemoryCache(cacheDir, displayName, CleanupAction.NO_OP);
    }

        inMemoryCache.put(key, entry);
        if (delegate != null) {
            delegate.store(key, entry);
        }
    }

    @Override
    protected ModuleArtifactsCacheEntry get(ArtifactsAtRepositoryKey key) {
        ModuleArtifactsCacheEntry entry = inMemoryCache.get(key);
        if (entry == null && delegate!=null) {

    protected void store(ModuleAtRepositoryKey key, ModuleVersionsCacheEntry entry) {
        inMemoryCache.put(key, entry);
        if (delegate != null) {
            delegate.store(key, entry);
        }
    }

    @Override
    protected ModuleVersionsCacheEntry get(ModuleAtRepositoryKey key) {
        ModuleVersionsCacheEntry entry = inMemoryCache.get(key);
        if (entry == null && delegate != null) {

        final CacheBuilder<Object, Object> cacheBuilder = CacheBuilder.newBuilder().maximumSize(maxSize).recordStats().removalListener(evictionListener);
        Cache<Object, Object> inMemoryCache = cacheBuilder.build();
        evictionListener.setCache(inMemoryCache);
        return inMemoryCache;
    }

    private class InMemoryCacheDecorator implements CacheDecorator {
        private final int maxEntriesToKeepInMemory;