// Ignore
                        }
                    }
                }
            }
            return model;
        }

        public Model computeIfAbsent(Supplier<Model> supplier) {
            if (!set) {
                synchronized (this) {
                    if (!set) {
                        this.set = true;
                        this.model = supplier.get();

    private final Map<String, Version> cache = new ConcurrentHashMap<>();

    public VersionParser() {
    }

    @Override
    public Version transform(String original) {
        return cache.computeIfAbsent(original, this::parse);
    }

    private Version parse(String original) {
        List<String> parts = new ArrayList<>();
        boolean digit = false;
        int startPart = 0;
        int pos = 0;

     */
    @Nullable
    public ToPlannedNodeConverter getConverter(Node node) {
        Class<? extends Node> nodeType = node.getClass();
        ToPlannedNodeConverter converter = convertersByNodeType.computeIfAbsent(nodeType, this::findConverter);
        return converter == MISSING_MARKER ? null : converter;
    }

    private ToPlannedNodeConverter findConverter(Class<? extends Node> nodeType) {

    public Optional<Type> lookup(String id) {
        return Optional.of(require(id));
    }

    @Override
    @Nonnull
    public Type require(String id) {
        nonNull(id, "id");
        return usedTypes.computeIfAbsent(id, i -> {
            Type type = types.get(id);
            if (type == null) {
                // Copy data as the ArtifactHandler is not immutable, but Type should be.

        ModuleComponentRepository<?> sourceRepository = findSourceRepository(component.getSources());
        ResolvableArtifact resolvableArtifact = sourceRepository.getArtifactCache().computeIfAbsent(artifact.getId(), id -> {
            CalculatedValue<File> artifactSource = calculatedValueFactory.create(Describables.of(artifact.getId()), () -> resolveArtifactLater(artifact, component.getSources(), sourceRepository));

            .map(PluginId::getId)
            .orElseGet { pluginClass.name }
        val pluginJar = findPluginJar(pluginClass)
        if (pluginJar != null) {
            jarsByPlugin.computeIfAbsent(pluginId) { firstSeenPlugin -> registerValidationTaskForNewPlugin(firstSeenPlugin, project, lifecycleTask) }
                .add(pluginJar)
        } else {

        }
        return version;
    }

    void put(Path pomFile, Model model) {
        modelsByPath.put(pomFile, model);
        modelsByGa
                .computeIfAbsent(new GAKey(getGroupId(model), model.getArtifactId()), k -> new HashSet<>())
                .add(model);
    }

    private static String getGroupId(Model model) {
        String groupId = model.getGroupId();

                            // Ignore
                        }
                    }
                }
            }
            return model;
        }

        public Model computeIfAbsent(Supplier<Model> supplier) {
            if (!set) {
                synchronized (this) {
                    if (!set) {
                        this.set = true;
                        this.model = supplier.get();

        return vertices.get(id);
    }

    public Collection<Vertex> getVertices() {
        return vertices.values();
    }

    Vertex addVertex(String label) {
        return vertices.computeIfAbsent(label, Vertex::new);
    }

    void addEdge(Vertex from, Vertex to) throws CycleDetectedException {
        from.children.add(to);
        to.parents.add(from);
        List<String> cycle = findCycle(to);

            this.buildIncluder = buildIncluder;
        }

        @Override
        public PluginResolutionResult resolve(PluginRequestInternal pluginRequest) {
            PluginResult resolutionResult = results.computeIfAbsent(pluginRequest.getId(), this::doResolve);
            if (resolutionResult == PluginResult.NOT_FOUND_IN_ANY_BUILD) {