) {
    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

    private
    val beanPropertyWriters = ConcurrentHashMap<Class<*>, BeanStateWriter>()

    override fun beanStateWriterFor(beanType: Class<*>): BeanStateWriter =
        beanPropertyWriters.computeIfAbsent(beanType, ::BeanPropertyWriter)

        this.delegate = delegate;
    }


    @Override
    public SubstitutionResult apply(DependencyMetadata dependency) {
        ComponentSelector selector = dependency.getSelector();
        return cache.computeIfAbsent(selector, s -> delegate.apply(dependency));
    }

        this.forClass = forClass
    }

    private void initializeLock() {
        if (lock == null) {
            synchronized (ClassBasedLock) {
                lock = locks.computeIfAbsent(forClass) { new ReentrantLock() }
            }
        }
    }

    @Override
    void lock() {
        initializeLock()
        lock.lock()
    }

    void unlock() {

     * @param mappingFunction function to create a {@link ResolvedVariant}
     * @return the resolved variant created by the function or a cached instance, if available
     */
    ResolvedVariant computeIfAbsent(Identifier key, Function<? super Identifier, ? extends ResolvedVariant> mappingFunction);

    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) {