if (setterInfo == null) {
            // Look for any method named "set" with one parameter
            Map<String, MethodInfo> classMethodCache = METHOD_CACHE.computeIfAbsent(beanType, this::buildMethodCache);
            setterInfo = classMethodCache.get("set");
        }

        if (setterInfo == null) {

@Deprecated(since = "4.0.0")
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) {

        vFrom.setCompareScope(scopedVertices);

        List<MetadataGraphEdge> exList = excidentEdges.computeIfAbsent(vFrom, k -> new ArrayList<>());

        if (!exList.contains(e)) {
            exList.add(e);
        }

        List<MetadataGraphEdge> inList = incidentEdges.computeIfAbsent(vTo, k -> new ArrayList<>());

        if (!inList.contains(e)) {
            inList.add(e);
        }

                allHandlers.clear();
            }
        }
    }

    @Override
    public ArtifactHandler getArtifactHandler(String id) {
        return allHandlers.computeIfAbsent(id, k -> {
            Type type = typeRegistry.require(id);
            return new DefaultArtifactHandler(
                    id,
                    type.getExtension(),
                    type.getClassifier(),

        lifecycle.allPhases().forEach(phase -> phase.plugins()
                .forEach(plugin -> plugin.getExecutions().forEach(exec -> exec.getGoals()
                        .forEach(goal -> goals.computeIfAbsent(phase.name(), n -> new ArrayList<>())
                                .add(plugin.getGroupId() + ":" + plugin.getArtifactId() + ":" + plugin.getVersion()
                                        + ":" + goal)))));

            }, depsTask);

            if (distribution.getPlatform() == Platform.WINDOWS) {
                windowsTestTasks.add(destructiveTask);
            } else {
                linuxTestTasks.computeIfAbsent(distribution.getType(), k -> new ArrayList<>()).add(destructiveTask);
            }
            destructiveDistroTest.configure(t -> t.dependsOn(destructiveTask));

     * Parses the phase identifier.
     *
     * @param phase the phase identifier.
     * @return the {@link PhaseId}.
     */
    public static synchronized PhaseId of(String phase) {
        return INSTANCES.computeIfAbsent(phase, PhaseId::new);
    }

    /**
     * Constructor.
     *
     * @param phase the phase identifier string.
     */
    private PhaseId(String phase) {
        int phaseStart;

        ConcurrentMap<String, ConcurrentMap<String, Object>> pluginContextsByKey =
                pluginContextsByProjectAndPluginKey.computeIfAbsent(projectKey, k -> new ConcurrentHashMap<>());

        String pluginKey = plugin.getPluginLookupKey();

        return pluginContextsByKey.computeIfAbsent(pluginKey, k -> new ConcurrentHashMap<>());
    }

    public ProjectDependencyGraph getProjectDependencyGraph() {

        
        // Mark channel as failed
        failedChannel.setState(ChannelState.FAILED);
        
        // Get or create failover state
        FailoverState state = failoverStates.computeIfAbsent(
            failedChannel.getChannelId(), 
            FailoverState::new
        );
        
        // Redistribute pending operations
        redistributePendingOperations(failedChannel);
        

        }
    }

    private fun MutableMap<String, MutableList<String>>.addToMap(filePath: String, values: List<String>) {
        this.computeIfAbsent(filePath) { mutableListOf() }.addAll(values)
    }