val shadowPackagePrefix =
        shadowPackage.takeIf(String::isNotEmpty)
            ?.let { it.replace('.', '/') + "/" }
            ?: ""

    operator fun get(className: String) =
        classes.computeIfAbsent(className) {
            val outputClassName = if (unshadedPackages.matches(className)) className else shadowPackagePrefix + className
            ClassDetails(outputClassName).also { classDetails ->

        this.delegate = delegate;
    }

    @Override
    public TestFramework createTestFramework(Test task) {
        return testFrameworks.computeIfAbsent(task.getIdentityPath(), k -> delegate.createTestFramework(task));
    }

    @Override
    public Iterable<Dependency> getCompileOnlyDependencies() {
        return delegate.getCompileOnlyDependencies();
    }

            Map<String, SomeToolingModel> model = fetchSomeModelForAllProjects(controller, buildModel, parameter);
            for (Map.Entry<String, SomeToolingModel> entry : model.entrySet()) {
                result.computeIfAbsent(entry.getKey(), k -> new ArrayList<>()).add(entry.getValue());
            }
        }

        return result;
    }

    }

    @Nullable
    V get(K key) {
        return map.get(new WeakKey<>(key));
    }

    Set<WeakKey<K>> keySet() {
        return map.keySet();
    }

    V computeIfAbsent(K key, AbsentValueProvider<V> absentValueProvider) {
        WeakKey<K> weakKey = new WeakKey<>(key);
        V value = map.get(weakKey);

        if (value == null) {
            value = absentValueProvider.provide();

                return context.locate(path);
            }

            @Override
            public String getUserProperty(String key) {
                return context.userProperties.computeIfAbsent(
                        key, k -> request.getUserProperties().get(key));
            }

            @Override
            public Model getRawModel(Path from, String gId, String aId) {

            storeOrigin(buildOperation, details.getTaskId());
        }
    }

    private void storeOrigin(BuildOperationDescriptor buildOperation, long taskId) {
        origins.computeIfAbsent(taskId, key -> {
            PluginApplication pluginApplication = pluginApplicationTracker.findRunningPluginApplication(buildOperation.getParentId());

    @Override
    public Model injectProfiles(
            Model model, List<Profile> profiles, ModelBuilderRequest request, ModelProblemCollector problems) {
        Model result = CACHE.computeIfAbsent(model, k -> new ConcurrentHashMap<>())
                .computeIfAbsent(profiles, l -> doInjectProfiles(model, profiles));
        return result == KEY ? model : result;
    }

    private Model doInjectProfiles(Model model, List<Profile> profiles) {

    /**
     * Returns the proper encoding provider for the given type, or null, if not covered by Java Object serialization.
     */
    fun encodingFor(type: Class<*>): Encoding? {
        return encodings.computeIfAbsent(type) { t -> calculateEncoding(t) }.encoding
    }

    private
    fun calculateEncoding(type: Class<*>): EncodingDetails {
        val candidates = type.allMethods()

import java.util.Set;

class Graph {

    final Map<String, Set<String>> graph = new LinkedHashMap<>();

    synchronized void addEdge(String from, String to) throws CycleDetectedException {
        if (graph.computeIfAbsent(from, l -> new HashSet<>()).add(to)) {
            List<String> cycle = visitCycle(graph, Collections.singleton(to), new HashMap<>(), new LinkedList<>());
            if (cycle != null) {

    public DefaultSuperPomProvider(ModelProcessor modelProcessor) {
        this.modelProcessor = modelProcessor;
    }

    @Override
    public Model getSuperModel(String version) {
        return SUPER_MODELS.computeIfAbsent(Objects.requireNonNull(version), v -> {
            String resource = "/org/apache/maven/model/pom-" + v + ".xml";

            InputStream is = getClass().getResourceAsStream(resource);

            if (is == null) {