model.getPluginRepositories(), pluginRepositories, projectBuildingRequest);
        } catch (Exception e) {
            event.problems()
                    .add(
                            BuilderProblem.Severity.ERROR,
                            ModelProblem.Version.BASE,
                            "Invalid plugin repository: " + e.getMessage(),
                            e);

                    return;
                }
                List<Path> toLoad = new ArrayList<>();
                Path root = defaultModelBuilder.getModelProcessor().locateExistingPom(rootDirectory);
                toLoad.add(root);
                while (!toLoad.isEmpty()) {
                    Path pom = toLoad.remove(0);
                    try {
                        ModelBuildingRequest gaBuildingRequest =

                    return;
                }
                List<Path> toLoad = new ArrayList<>();
                Path root = defaultModelBuilder.getModelProcessor().locateExistingPom(rootDirectory);
                toLoad.add(root);
                while (!toLoad.isEmpty()) {
                    Path pom = toLoad.remove(0);
                    try {
                        ModelBuilderRequest gaBuildingRequest =

            if (optSelectedProject.isPresent()) {
                resolvedOptionalProjects.add(optSelectedProject.get());
                resolvedOptionalProjects.addAll(getChildProjects(optSelectedProject.get(), request));
            } else {
                unresolvedOptionalSelectors.add(selector);
            }
        }

        if (!unresolvedOptionalSelectors.isEmpty()) {

                Server server = servers.get(i);

                validateStringNotEmpty(problems, "servers.server[" + i + "].id", server.getId(), null);

                if (!serverIds.add(server.getId())) {
                    addViolation(
                            problems,
                            BuilderProblem.Severity.WARNING,
                            "servers.server.id",

        basicToolchains.add(basicToolchainModel);
        basicToolchains.add(basicToolchainModel);
        groupedToolchains.put("basic", basicToolchains);

        List<ToolchainModel> rareToolchains = new ArrayList<>();
        ToolchainModel rareToolchainModel = new ToolchainModel();
        rareToolchainModel.setType("rare");
        rareToolchains.add(rareToolchainModel);

            if (filter.include(artifact)) {
                return true;
            }
        }

        return false;
    }

    public void add(ArtifactFilter artifactFilter) {
        filters.add(artifactFilter);
    }

    @Override
    public int hashCode() {
        int hash = 17;
        hash = hash * 31 + filters.hashCode();
        return hash;
    }

    @Override

            if (!filter.include(artifact)) {
                include = false;
            }
        }
        return include;
    }

    public void add(ArtifactFilter artifactFilter) {
        filters.add(artifactFilter);
    }

    public List<ArtifactFilter> getFilters() {
        return new ArrayList<>(filters);
    }

    @Override
    public int hashCode() {

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) {
                // remove edge which introduced cycle

            for (ProjectBuildingResult result : results) {
                ExceptionSummary child = handle(result);
                if (child != null) {
                    children.add(child);
                }
            }

            message = "The build could not read " + children.size() + " project" + (children.size() == 1 ? "" : "s");
        } else {