this.type = type;
            this.calculatedValueContainerFactory = calculatedValueContainerFactory;
        }

        @Override
        public V computeIfAbsent(K key, Function<K, V> factory) {
            CalculatedValue<V> value = cache.computeIfAbsent(key, k ->
                calculatedValueContainerFactory.create(
                    Describables.of(k, type),
                    context -> factory.apply(k)

            registerMapping(key, pkgInfo);
        }
    }

    private Optional<String> findRelativePath(File asSourceFile) {
        return relativePaths.computeIfAbsent(asSourceFile, relativize);
    }

    private String normalizeName(TypeElement typeElement) {
        String symbol = typeElement.getQualifiedName().toString();
        if (symbol.endsWith("module-info")) {

    }

    public static CallSiteDecorator getGroovyCallDecorator(BytecodeInterceptorFilter interceptorFilter) {
        return groovyDecorators.computeIfAbsent(interceptorFilter, key -> new DefaultCallSiteDecorator(currentGroovyCallInterceptorSet.getCallInterceptors(interceptorFilter)));
    }

    private val map = ConcurrentHashMap<Long, V>()

    @Suppress("NOTHING_TO_INLINE")
    inline operator fun getValue(thisRef: Any?, property: KProperty<*>): V =
        map.computeIfAbsent(Thread.currentThread().id) {
            init()
        }
}

internal fun <V : Any> threadLocal(init: () -> V): ThreadLocalValue<V> =

        return allRepositories.computeIfAbsent(repository, DefaultRemoteRepository::new);
    }

    @Override
    public Node getNode(org.eclipse.aether.graph.DependencyNode node) {
        return getNode(node, false);
    }

    @Override
    public Node getNode(org.eclipse.aether.graph.DependencyNode node, boolean verbose) {
        return allNodes.computeIfAbsent(node, n -> new DefaultNode(this, n, verbose));

    public Map getPluginContext(PluginDescriptor plugin, MavenProject project) {
        Map<String, Map> pluginContextsByKey =
                pluginContextsByProjectAndPluginKey.computeIfAbsent(project.getId(), k -> new HashMap<>());

        return pluginContextsByKey.computeIfAbsent(plugin.getPluginLookupKey(), k -> new HashMap<>());
    }

    public void setFailureBehavior(String failureBehavior) {
        if (failureBehavior == null) {

        }
    }

    private Set<String> computeAndCacheInstrumentedSuperTypes(String type, Set<String> visited) {
        // We intentionally avoid using computeIfAbsent, since ConcurrentHashMap doesn't allow map modifications in the computeIfAbsent map function.
        // The result is, that multiple threads could recalculate the same key multiple times, but that is not a problem in our case.

import java.util.function.Function


class ConfigurationCacheAwareLocalComponentCache(
    private val cache: BuildTreeConfigurationCache
) : LocalComponentCache {
    override fun computeIfAbsent(project: ProjectState, factory: Function<ProjectState, LocalComponentGraphResolveState>): LocalComponentGraphResolveState {
        return cache.loadOrCreateProjectMetadata(project.identityPath) {
            factory.apply(project)

    public ComponentMetaDataResolver getComponentMetadataResolver() {
        return metaDataResolver;
    }

    private ModuleResolveState getModule(ModuleIdentifier id, boolean rootModule) {
        return modules.computeIfAbsent(id, mid -> new ModuleResolveState(idGenerator, id, metaDataResolver, attributesFactory, versionComparator, versionParser, selectorStateResolver, resolveOptimizations, rootModule, conflictResolution));
    }

    @Override

    }

    private fun getOrCalculatePluginDescriptor(
        designation: PluginDesignation,
    ): RawPluginDescriptor = pluginDescriptorsCache.computeIfAbsent(designation) {
        val descriptor = RawPluginDescriptor()
        PluginXmlPathResolver.DEFAULT_PATH_RESOLVER.resolvePath(
            readContext = ReadContext,