}
        });
        writeLn("}");
        writeLn();
    }

    private String getClassName(ClassNode classNode) {
        return classNameCache.computeIfAbsent(classNode, this::getClassName0);
    }

    private String getClassName0(ClassNode classNode) {
        String name = classNode.getClassName();
        String loweredName = name.toLowerCase();

            throws UnresolvableModelException {
        Result result;
        try {
            Future<Result> future = parentCache.computeIfAbsent(parent.getId(), id -> {
                ForkJoinPool pool = new ForkJoinPool(MAX_CAP);
                ForkJoinTask<Result> task = new ForkJoinTask<>() {
                    Result result;

        public void addProgressListener(ProgressListener listener, Set<OperationType> eventTypes) {
            for (OperationType type : eventTypes) {
                List<ProgressListener> listeners = this.progressListeners.computeIfAbsent(type, new Function<OperationType, List<ProgressListener>>() {
                    @Override
                    public List<ProgressListener> apply(OperationType operationType) {

        SessionData data = request.getRepositorySession().getData();
        return (ConcurrentMap<Key, PluginVersionResult>)
                data.computeIfAbsent(CACHE_KEY, () -> new ConcurrentHashMap<>(256));
    }

    private static Key getKey(PluginVersionRequest request) {
        return new Key(request.getGroupId(), request.getArtifactId(), request.getRepositories());

        Map<Path, List<ProjectComponentPublication>> map = [:]

        void register(Path identityPath, ProjectComponentPublication... publications) {
            map.computeIfAbsent(identityPath, { [] }).addAll(publications)
        }

        @Override
        <T extends ProjectPublication> Collection<ProjectComponentPublication> getPublications(Class<T> type, Path projectIdentityPath) {

        } else {
            return cache.computeIfAbsent(groupId, artifactId, version, tag, s);
        }
    }

    private static <T> T cache(ModelCache cache, Source source, String tag, Callable<T> supplier) {
        Supplier<T> s = asSupplier(supplier);
        if (cache == null) {
            return s.get();
        } else {
            return cache.computeIfAbsent(source, tag, s);
        }
    }

        }
    }

    public ComponentState getVersion(ModuleVersionIdentifier id, ComponentIdentifier componentIdentifier) {
        assert id.getModule().equals(this.id);
        return versions.computeIfAbsent(id, k ->
            new ComponentState(idGenerator.nextGraphNodeId(), this, id, componentIdentifier, metaDataResolver)
        );
    }

    void addSelector(SelectorState selector, boolean deferSelection) {

     *
     * @param type the type of path (class-path, module-path, …)
     * @param path the path element to add
     */
    private void addPathElement(PathType type, Path path) {
        dispatchedPaths.computeIfAbsent(type, (t) -> new ArrayList<>()).add(path);
    }

    /**
     * Adds main and test output directories to the result. This method adds the main output directory

                    if (mergeChildren && childDom != null) {
                        String name = recessiveChild.getName();
                        Iterator<XmlNode> it =
                                commonChildren.computeIfAbsent(name, n1 -> Stream.of(dominant.getChildren().stream()
                                                .filter(n2 -> n2.getName().equals(n1))
                                                .collect(Collectors.toList()))

                if (mgmt != null) {
                    for (Plugin plugin : mgmt.getPlugins()) {
                        String key = plugin.getKey();
                        managedVersions.computeIfAbsent(key, k -> plugin.getVersion());
                    }
                }
            }
        }

        for (String key : versions.keySet()) {