Attribute<?> attribute = candidateAttribute.getAttribute();
                Set<String> unrequestedValuesForAttribute = unrequestedAttributesWithValues.computeIfAbsent(attribute.getName(), name -> new HashSet<>());
                unrequestedValuesForAttribute.add(Objects.requireNonNull(candidateAttribute.getProvided()).toString());
            });
        });

private
class EnvironmentEncoder : ClassEncoder {

    private
    val refs = IdentityHashMap<Class<*>, Int>()

    override fun WriteContext.encodeClass(type: Class<*>) {
        writeSmallInt(refs.computeIfAbsent(type) { refs.size })
    }

    fun getResultingEnvironment(): Map<Int, Any> =
        refs.invert()
}


private
class EnvironmentDecoder(
    val environment: Map<Int, Any>

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

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

        }

        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

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

        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)

        ResolutionFailureDescriber<?> describer = instanceGenerator.newInstance(describerType);
        describers.computeIfAbsent(failureType, k -> new ArrayList<>()).add(describer);
    }

        }

        @SuppressWarnings("unchecked")
        public <T> Provider<T> scope(Key<T> key, Provider<T> unscoped) {
            Provider<?> provider = provided.computeIfAbsent(key, k -> new CachingProvider<>(unscoped));
            return (Provider<T>) provider;
        }

        public Collection<CachingProvider<?>> providers() {
            return provided.values();
        }
    }