Examples with ExcludeAnyOf org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.ExcludeAnyOf used on opensource projects

Example 1 with ExcludeAnyOf

use of org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.ExcludeAnyOf in project gradle by gradle.

the class Intersections method intersectAnyOf.

private ExcludeSpec intersectAnyOf(ExcludeAnyOf left, ExcludeSpec right) {
    Set<ExcludeSpec> leftComponents = left.getComponents();
    if (right instanceof ExcludeAnyOf) {
        Set<ExcludeSpec> rightComponents = ((ExcludeAnyOf) right).getComponents();
        Set<ExcludeSpec> common = Sets.newHashSet(leftComponents);
        common.retainAll(rightComponents);
        if (common.size() >= 1) {
            ExcludeSpec alpha = asUnion(common);
            if (leftComponents.equals(common) || rightComponents.equals(common)) {
                return alpha;
            }
            Set<ExcludeSpec> remainderLeft = Sets.newHashSet(leftComponents);
            remainderLeft.removeAll(common);
            Set<ExcludeSpec> remainderRight = Sets.newHashSet(rightComponents);
            remainderRight.removeAll(common);
            ExcludeSpec unionLeft = asUnion(remainderLeft);
            ExcludeSpec unionRight = asUnion(remainderRight);
            ExcludeSpec beta = factory.allOf(unionLeft, unionRight);
            return factory.anyOf(alpha, beta);
        } else {
            // slowest path, full distribution
            // (A ∪ B) ∩ (C ∪ D) = (A ∩ C) ∪ (A ∩ D) ∪ (B ∩ C) ∪ (B ∩ D)
            Set<ExcludeSpec> intersections = Sets.newHashSetWithExpectedSize(leftComponents.size() * rightComponents.size());
            for (ExcludeSpec leftSpec : leftComponents) {
                for (ExcludeSpec rightSpec : rightComponents) {
                    ExcludeSpec merged = tryIntersect(leftSpec, rightSpec);
                    if (merged == null) {
                        merged = factory.allOf(leftSpec, rightSpec);
                    }
                    if (!(merged instanceof ExcludeNothing)) {
                        intersections.add(merged);
                    }
                }
            }
            return asUnion(intersections);
        }
    } else {
        // Here, we will distribute A ∩ (B ∪ C) if, and only if, at
        // least one of the distribution operations (A ∩ B) can be simplified
        ExcludeSpec[] excludeSpecs = leftComponents.toArray(new ExcludeSpec[0]);
        ExcludeSpec[] intersections = null;
        for (int i = 0; i < excludeSpecs.length; i++) {
            ExcludeSpec excludeSpec = tryIntersect(excludeSpecs[i], right);
            if (excludeSpec != null) {
                if (intersections == null) {
                    intersections = new ExcludeSpec[excludeSpecs.length];
                }
                intersections[i] = excludeSpec;
            }
        }
        if (intersections != null) {
            Set<ExcludeSpec> simplified = Sets.newHashSetWithExpectedSize(excludeSpecs.length);
            for (int i = 0; i < intersections.length; i++) {
                ExcludeSpec intersection = intersections[i];
                if (intersection instanceof ExcludeNothing) {
                    continue;
                }
                if (intersection != null) {
                    simplified.add(intersection);
                } else {
                    simplified.add(factory.allOf(excludeSpecs[i], right));
                }
            }
            return asUnion(simplified);
        }
    }
    return null;
}

Example 2 with ExcludeAnyOf

use of org.gradle.api.internal.artifacts.ivyservice.resolveengine.excludes.specs.ExcludeAnyOf in project gradle by gradle.

the class NormalizingExcludeFactory method doUnion.

private ExcludeSpec doUnion(Set<ExcludeSpec> specs) {
    specs = simplifySet(ExcludeAllOf.class, specs);
    FlattenOperationResult flattened = flatten(ExcludeAnyOf.class, specs, ExcludeEverything.class::isInstance, ExcludeNothing.class::isInstance);
    if (flattened.fastExit) {
        return everything();
    }
    if (flattened.result.isEmpty()) {
        return nothing();
    }
    Map<UnionOf, List<ExcludeSpec>> byType = flattened.result.stream().collect(Collectors.groupingBy(UnionOf::typeOf));
    List<ModuleIdExclude> moduleIdExcludes = UnionOf.MODULEID.fromMap(byType);
    List<ModuleIdSetExclude> moduleIdSetsExcludes = UnionOf.MODULEID_SET.fromMap(byType);
    List<GroupExclude> groupExcludes = UnionOf.GROUP.fromMap(byType);
    List<GroupSetExclude> groupSetExcludes = UnionOf.GROUP_SET.fromMap(byType);
    List<ModuleExclude> moduleExcludes = UnionOf.MODULE.fromMap(byType);
    List<ModuleSetExclude> moduleSetExcludes = UnionOf.MODULE_SET.fromMap(byType);
    List<ExcludeSpec> other = UnionOf.NOT_JOINABLE.fromMap(byType);
    if (!moduleIdExcludes.isEmpty()) {
        // If there's more than one module id, merge them into a module id set
        if (moduleIdExcludes.size() > 1 || !moduleIdSetsExcludes.isEmpty()) {
            ModuleIdSetExclude excludeSpec = delegate.moduleIdSet(moduleIdExcludes.stream().map(ModuleIdExclude::getModuleId).collect(toSet()));
            if (moduleIdSetsExcludes.isEmpty()) {
                moduleIdSetsExcludes = ImmutableList.of(excludeSpec);
            } else {
                moduleIdSetsExcludes.add(excludeSpec);
            }
            moduleIdExcludes = Collections.emptyList();
        }
    }
    if (!groupExcludes.isEmpty()) {
        // If there's more than group, merge them into a group set
        if (groupExcludes.size() > 1 || !groupSetExcludes.isEmpty()) {
            GroupSetExclude excludeSpec = delegate.groupSet(groupExcludes.stream().map(GroupExclude::getGroup).collect(toSet()));
            if (groupSetExcludes.isEmpty()) {
                groupSetExcludes = ImmutableList.of(excludeSpec);
            } else {
                groupSetExcludes.add(excludeSpec);
            }
            groupExcludes = Collections.emptyList();
        }
    }
    if (!moduleExcludes.isEmpty()) {
        // If there's more than one module, merge them into a module set
        if (moduleExcludes.size() > 1 || !moduleSetExcludes.isEmpty()) {
            ModuleSetExclude excludeSpec = delegate.moduleSet(moduleExcludes.stream().map(ModuleExclude::getModule).collect(toSet()));
            if (moduleSetExcludes.isEmpty()) {
                moduleSetExcludes = ImmutableList.of(excludeSpec);
            } else {
                moduleSetExcludes.add(excludeSpec);
            }
            moduleExcludes = Collections.emptyList();
        }
    }
    if (moduleIdSetsExcludes.size() > 1) {
        moduleIdSetsExcludes = ImmutableList.of(delegate.moduleIdSet(moduleIdSetsExcludes.stream().flatMap(e -> e.getModuleIds().stream()).collect(toSet())));
    }
    if (groupSetExcludes.size() > 1) {
        groupSetExcludes = ImmutableList.of(delegate.groupSet(groupSetExcludes.stream().flatMap(e -> e.getGroups().stream()).collect(toSet())));
    }
    if (moduleSetExcludes.size() > 1) {
        moduleSetExcludes = ImmutableList.of(delegate.moduleSet(moduleSetExcludes.stream().flatMap(e -> e.getModules().stream()).collect(toSet())));
    }
    ImmutableSet.Builder<ExcludeSpec> builder = ImmutableSet.builderWithExpectedSize(moduleIdExcludes.size() + groupExcludes.size() + moduleExcludes.size() + moduleIdSetsExcludes.size() + groupSetExcludes.size() + moduleSetExcludes.size() + other.size());
    builder.addAll(moduleIdExcludes);
    builder.addAll(groupExcludes);
    builder.addAll(moduleExcludes);
    builder.addAll(moduleIdSetsExcludes);
    builder.addAll(groupSetExcludes);
    builder.addAll(moduleSetExcludes);
    builder.addAll(other);
    Set<ExcludeSpec> elements = builder.build();
    if (elements.size() > 1) {
        // try simplify
        ExcludeSpec[] asArray = elements.toArray(new ExcludeSpec[0]);
        boolean simplified = false;
        for (int i = 0; i < asArray.length; i++) {
            ExcludeSpec left = asArray[i];
            if (left != null) {
                for (int j = 0; j < asArray.length; j++) {
                    ExcludeSpec right = asArray[j];
                    if (right != null && i != j) {
                        ExcludeSpec merged = unions.tryUnion(left, right);
                        if (merged != null) {
                            if (merged instanceof ExcludeEverything) {
                                return merged;
                            }
                            left = merged;
                            asArray[i] = merged;
                            asArray[j] = null;
                            simplified = true;
                        }
                    }
                }
            }
        }
        if (simplified) {
            elements = Arrays.stream(asArray).filter(Objects::nonNull).collect(toSet());
        }
    }
    if (elements.size() == 2) {
        // Corner case to handle one of the two elements being an anyOf
        Iterator<ExcludeSpec> specIterator = elements.iterator();
        ExcludeSpec first = specIterator.next();
        ExcludeSpec second = specIterator.next();
        if (first instanceof ExcludeAnyOf || second instanceof ExcludeAnyOf) {
            ImmutableSet.Builder<ExcludeSpec> newBuilder = ImmutableSet.builder();
            if (first instanceof ExcludeAnyOf) {
                newBuilder.addAll(((ExcludeAnyOf) first).getComponents());
            } else {
                builder.add(first);
            }
            if (second instanceof ExcludeAnyOf) {
                newBuilder.addAll(((ExcludeAnyOf) second).getComponents());
            } else {
                builder.add(second);
            }
            elements = builder.build();
        }
    }
    return Optimizations.optimizeCollection(this, elements, delegate::anyOf);
}