}

    @Override
    @Nullable
    public Object computeIfAbsent(Object key, Function<? super Object, ?> mappingFunction) {
        Object oldValue;
        Object computedValue = null;
        synchronized (delegate) {
            oldValue = delegate.get(key);
            if (oldValue == null) {
                computedValue = delegate.computeIfAbsent(key, mappingFunction);
            }
        }

    }

    private Set<NodeState> findNodesFor(CapabilityInternal capability) {
        String capabilityId = capability.getCapabilityId();

        return capabilityWithoutVersionToNodes.computeIfAbsent(capabilityId, k -> new LinkedHashSet<>());
    }

    @Override
    public boolean hasConflicts() {
        return !conflicts.isEmpty();
    }

    @Override

            return ruleChain.doesSomething();
        }
    }

    /**
     * Recursively calling {@link Map#computeIfAbsent(Object, Function)} to insert multiple keys could pose issues, depending on the implementation of the underlying map.
     *
     * This method exists to externalize that usage and avoid the potential for these sort of issues.

     * be called multiple times for the same type.
     */
    private
    fun readObjectMethodHierarchyForDecoding(type: Class<*>): List<Method> =
        readObjectHierarchy.computeIfAbsent(type) {
            readObjectMethodHierarchyFrom(it.allMethods())
        }
}


internal
fun Method.isReadResolve() =
    !isStatic(modifiers)
        && parameterCount == 0

    }

    public AttributeContainerInternal getAttributes(@Nullable String variantName) {
        if (variantName == null) {
            return baseAttributes;
        } else {
            return variantAttributes.computeIfAbsent(variantName, name -> attributesFactory.mutable(baseAttributes));
        }
    }

    protected AttributeContainerInternal joinVariantAttributes(VariantResolveMetadata variant, AttributeContainerInternal parent) {

            } catch (IOException e) {
                throw new RuntimeException("Unable to load unique lockfile", e);
            }
            for (String emptyLockId : emptyLockIds) {
                uniqueLockState.computeIfAbsent(emptyLockId, k -> new ArrayList<>());
            }
            return uniqueLockState;
        } else {
            return new HashMap<>();
        }
    }

        fun sourceData(node: LighterASTNode, offset: Int = sourceOffset): LightTreeSourceData =
            sourceData.computeIfAbsent(node) {
                it.sourceData(sourceIdentifier, sourceCode, offset)
            }

        fun rootSourceData(): LightTreeSourceData =
            sourceData.computeIfAbsent(root) {

            throw new UncheckedIOException(e);
        }
    }

    private Loader getLoader(ProtectionDomain domain) {
        // This is a very verbose Java 6-compatible way of doing
        // return loaders.computeIfAbsent(domain, this::createLoaderForDomain).
        Loader transformLoader = loaders.get(domain);
        if (transformLoader == null) {
            transformLoader = storeIfAbsent(domain, createLoaderForDomain(domain));

            this.instantiatorFactory = instantiatorFactory;
        }

        public <T extends JvmTestToolchain<?>> T getOrCreate(Class<T> type) {
            return uncheckedCast(cache.computeIfAbsent(type, t -> create(uncheckedCast(type))));
        }

        private <T extends JvmTestToolchainParameters> JvmTestToolchain<T> create(Class<? extends JvmTestToolchain<T>> type) {

        if (parent == null) {
            return false;
        }
        if (isAncestorASymlink(symlinkCache, parent)) {
            return true;
        }
        return symlinkCache.computeIfAbsent(parent.getAbsolutePath(), __ -> Files.isSymbolicLink(parent.toPath()));
    }

    @CheckReturnValue