private final ConcurrentMap<K, V> map = new ConcurrentHashMap<>(256);

    @Override
    public V get(K key, Function<? super K, ? extends V> factory) {
        return map.computeIfAbsent(key, factory);
    }

    @Override
    public V getIfPresent(K key) {
        return map.get(key);
    }

    @Override
    public void put(K key, V value) {
        map.put(key, value);
    }

                return context.locate(path);
            }

            @Override
            public String getUserProperty(String key) {
                return context.userProperties.computeIfAbsent(
                        key, k -> request.getUserProperties().getProperty(key));
            }

            @Override
            public Model getRawModel(Path from, String gId, String aId) {

    public void setPluginVersionAt(ClassLoaderScope scope, String pluginId, String pluginVersion) {
        Map<String, String> pluginVersions = pluginVersionsPerScope.computeIfAbsent(scope.getOriginalScope(), ignored -> new ConcurrentHashMap<>());
        if (pluginVersions.containsKey(pluginId)) {
            throw new IllegalStateException("Plugin version already set for " + pluginId);
        }

        this.compilerPluginsClasspath = compilerPluginsClasspath;
    }

    @Override
    public ContextAwareJavaCompiler create() {
        JdkTools jdkTools = JavaHomeBasedJavaCompilerFactory.JDK_TOOLS.computeIfAbsent(compilerPluginsClasspath, JavaHomeBasedJavaCompilerFactory::createJdkTools);
        return jdkTools.getSystemJavaCompiler();
    }

    private static JdkTools createJdkTools(List<File> compilerPluginsClasspath) {

        for (Map.Entry<String, ? extends Collection<String>> entry : sourceClassesMapping.entrySet()) {
            for (String cls : entry.getValue()) {
                reverse.computeIfAbsent(cls, key -> new HashSet<>()).add(entry.getKey());
            }
        }
        return reverse;
    }

    @Override
    public Set<String> getClassNames(String sourceFileRelativePath) {

    @Override
    public JvmInstallationMetadata getMetadata(InstallationLocation javaInstallationLocation) {
        File javaHome = resolveSymlink(javaInstallationLocation.getLocation());
        return javaMetadata.computeIfAbsent(javaHome, file -> delegate.getMetadata(javaInstallationLocation));
    }

    private File resolveSymlink(File jdkPath) {
        try {
            return jdkPath.getCanonicalFile();
        } catch (IOException e) {

    val shadowPackagePrefix =
        shadowPackage.takeIf(String::isNotEmpty)
            ?.let { it.replace('.', '/') + "/" }
            ?: ""

    operator fun get(className: String) =
        classes.computeIfAbsent(className) {
            val outputClassName = if (unshadedPackages.matches(className)) className else shadowPackagePrefix + className
            ClassDetails(outputClassName).also { classDetails ->

        this.delegate = delegate;
    }

    @Override
    public TestFramework createTestFramework(Test task) {
        return testFrameworks.computeIfAbsent(task.getIdentityPath(), k -> delegate.createTestFramework(task));
    }

    @Override
    public Iterable<Dependency> getCompileOnlyDependencies() {
        return delegate.getCompileOnlyDependencies();
    }

            Map<String, SomeToolingModel> model = fetchSomeModelForAllProjects(controller, buildModel, parameter);
            for (Map.Entry<String, SomeToolingModel> entry : model.entrySet()) {
                result.computeIfAbsent(entry.getKey(), k -> new ArrayList<>()).add(entry.getValue());
            }
        }

        return result;
    }

    }

    @Nullable
    V get(K key) {
        return map.get(new WeakKey<>(key));
    }

    Set<WeakKey<K>> keySet() {
        return map.keySet();
    }

    V computeIfAbsent(K key, AbsentValueProvider<V> absentValueProvider) {
        WeakKey<K> weakKey = new WeakKey<>(key);
        V value = map.get(weakKey);

        if (value == null) {
            value = absentValueProvider.provide();