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> =

    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)

    }

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

}


private
class CachedHierarchyAnnotationChecker(private val annotationType: KClass<out Annotation>) {
    fun isAnnotatedMaybeInSupertypes(kClass: KClass<*>): Boolean {
        // Can't use computeIfAbsent because of recursive calls
        hasRestrictedAnnotationWithSuperTypesCache[kClass]?.let { return it }
        return hasRestrictedAnnotationWithSuperTypes(kClass).also { hasRestrictedAnnotationCache[kClass] = it }
    }

) {
    private
    val methodCache = hashMapOf<Class<*>, Method?>()

    fun forObject(value: Any) =
        forClass(value.javaClass)

    fun forClass(type: Class<*>) = methodCache.computeIfAbsent(type) {
        it.firstAccessibleMatchingMethodOrNull(predicate)
    }
}


internal
fun Class<*>.firstAccessibleMatchingMethodOrNull(predicate: Method.() -> Boolean): Method? =

     * Loads cached dependency resolution metadata for the given project, if available,
     * or else runs the given function to create it and then writes the result to the cache.
     */
    LocalComponentGraphResolveState computeIfAbsent(ProjectState project, Function<ProjectState, LocalComponentGraphResolveState> factory);

) : BeanStateReaderLookup {

    private
    val beanStateReaders = ConcurrentHashMap<Class<*>, BeanStateReader>()

    override fun beanStateReaderFor(beanType: Class<*>): BeanStateReader =
        beanStateReaders.computeIfAbsent(beanType) { type -> BeanPropertyReader(type, constructors, instantiatorFactory) }

        // use original key
        return parent.replace(key, value);
    }

    @Override
    public V computeIfAbsent(final K key, final Function<? super K, ? extends V> mappingFunction) {
        // use original key
        return parent.computeIfAbsent(key, mappingFunction);
    }

    @Override