private boolean loadAliasFromArray()

in src/main/java/org/apache/sling/resourceresolver/impl/mapping/AliasHandler.java [457:513]
52 lines of code
8 McCabe index (conditional complexity)

    private boolean loadAliasFromArray(
            final String[] aliasArray,
            Map<String, Map<String, Collection<String>>> map,
            List<String> conflictingAliases,
            List<String> invalidAliases,
            final String resourceName,
            final String parentPath) {

        boolean hasAlias = false;

        log.debug("Found alias, total size {}", aliasArray.length);

        // the order matters here, the first alias in the array must come first
        for (final String alias : aliasArray) {
            if (isAliasInvalid(alias)) {
                long invalids = detectedInvalidAliases.incrementAndGet();
                log.warn(
                        "Encountered invalid alias '{}' under parent path '{}' (total so far: {}). Refusing to use it.",
                        alias,
                        parentPath,
                        invalids);
                if (invalidAliases != null && invalids < MAX_REPORT_DEFUNCT_ALIASES) {
                    invalidAliases.add((String.format("'%s'/'%s'", parentPath, alias)));
                }
            } else {
                Map<String, Collection<String>> parentMap =
                        map.computeIfAbsent(parentPath, key -> new ConcurrentHashMap<>());
                Optional<String> siblingResourceNameWithDuplicateAlias = parentMap.entrySet().stream()
                        .filter(entry -> !entry.getKey().equals(resourceName)) // ignore entry for the current resource
                        .filter(entry -> entry.getValue().contains(alias))
                        .findFirst()
                        .map(Map.Entry::getKey);
                if (siblingResourceNameWithDuplicateAlias.isPresent()) {
                    long conflicting = detectedConflictingAliases.incrementAndGet();
                    log.warn(
                            "Encountered duplicate alias '{}' under parent path '{}'. Refusing to replace current target '{}' with '{}' (total duplicated aliases so far: {}).",
                            alias,
                            parentPath,
                            siblingResourceNameWithDuplicateAlias.get(),
                            resourceName,
                            conflicting);
                    if (conflictingAliases != null && conflicting < MAX_REPORT_DEFUNCT_ALIASES) {
                        conflictingAliases.add((String.format(
                                "'%s': '%s'/'%s' vs '%s'/'%s'",
                                parentPath, resourceName, alias, siblingResourceNameWithDuplicateAlias.get(), alias)));
                    }
                } else {
                    Collection<String> existingAliases =
                            parentMap.computeIfAbsent(resourceName, name -> new CopyOnWriteArrayList<>());
                    existingAliases.add(alias);
                    hasAlias = true;
                }
            }
        }

        return hasAlias;
    }