Transformer<LocalComponentArtifactMetadata, LocalComponentArtifactMetadata> cachedTransformer = oldArtifact ->
            transformedArtifacts.computeIfAbsent(oldArtifact, transformer::transform);

        LocalComponentGraphResolveMetadata originalMetadata = getMetadata();
        LocalComponentGraphResolveMetadata copiedMetadata = new LocalComponentGraphResolveMetadata(

    }

    private void addMojoExecution(
            Map<Integer, List<MojoExecution>> phaseBindings, MojoExecution mojoExecution, int priority) {
        List<MojoExecution> mojoExecutions = phaseBindings.computeIfAbsent(priority, k -> new ArrayList<>());

        mojoExecutions.add(mojoExecution);
    }

        }

        return readValue(key, address)
    }

    private
    fun loadOrCreateAddress(key: K, creator: () -> V): BlockAddress {
        val valueContainer = currentValues.computeIfAbsent(key) { k ->
            createContainer(k, creator)
        }

        // Calculate the value after adding the entry to the map, so that the value container can take care of thread synchronization

    public void flush() {
        descriptors.clear();
    }

    public Key createKey(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session) {
        return keys.computeIfAbsent(new CacheKey(plugin, repositories, session), k -> k);
    }

    public PluginDescriptor get(Key cacheKey) {
        return clone(descriptors.get(cacheKey));
    }

    @Override

                String actualLine = actualLines.get(actualIdx);
                if (Objects.equals(expectedLine, actualLine) && !StringUtils.isEmpty(expectedLine)) {
                    result.computeIfAbsent(expectedIdx, matches -> new ArrayList<>()).add(actualIdx);
                }
            }
        }
        return result;
    }

    DependencyTree calculateClassDependencies(int project, int first, int last) {
        (first..last).each {
            classToproject.put(it, project)
            placeNode(it, CLASSES_ON_LEVEL, classDependencyTrees.computeIfAbsent(project) {[]}, parentToChildClassIds)
        }
        this
    }

    DependencyTree calculateProjectDependencies() {
        (0..classDependencyTrees.size() - 1).each {

        return projects == null ? null : map(projects, this::getProject);
    }

    @Override
    public Project getProject(MavenProject project) {
        return allProjects.computeIfAbsent(project.getId(), id -> new DefaultProject(this, project));
    }

    @Override
    public List<ArtifactRepository> toArtifactRepositories(List<RemoteRepository> repositories) {

        targetTypesOf(accessorSpec.name).add(accessorSpec.receiver)

    private
    fun targetTypesOf(accessorNameSpec: AccessorNameSpec): HashSet<TypeAccessibility.Accessible> =
        targetTypesByName.computeIfAbsent(accessorNameSpec) { hashSetOf() }
}


internal
fun extensionAccessor(spec: TypedAccessorSpec): String = spec.run {
    when (type) {

     * @param supplier the supplier will compute the new value
     * @return the session data associated with the key
     */
    @Nullable
    <T> T computeIfAbsent(@Nonnull Key<T> key, @Nonnull Supplier<T> supplier);

    /**
     * Create a key using the given class as an identifier and as the type of the object.
     */
    static <T> Key<T> key(Class<T> clazz) {

        NULL_VALUE -> null
        else -> bindings[tag].decoding.run { decode() }
    }

    private
    fun taggedEncodingFor(type: Class<*>): TaggedEncoding =
        encodings.computeIfAbsent(type, ::computeEncoding)

    private
    fun computeEncoding(type: Class<*>): TaggedEncoding {
        for (binding in bindings) {
            val encoding = binding.encodingForType(type)