.collect(Collectors.toMap(n -> n.name, n -> n));
                // for each phase, make sure children phases are executed between before and after steps
                lifecycle.allPhases().forEach(phase -> phase.phases().forEach(child -> {
                    steps.get(BEFORE + child.name()).executeAfter(steps.get(BEFORE + phase.name()));
                    steps.get(AFTER + phase.name()).executeAfter(steps.get(AFTER + child.name()));

        if (logger.isDebugEnabled()) {
            writePlan(logger::debug, plan, project);
        }
    }

    public void writePlan(Consumer<String> writer, BuildPlan plan) {
        plan.projects().forEach(project -> writePlan(writer, plan, project));
    }

    public void writePlan(Consumer<String> writer, BuildPlan plan, MavenProject project) {

            final String key = LaFunctions.u(e.getKey());
            stream(e.getValue()).of(stream -> stream.filter(StringUtil::isNotBlank)
                    .forEach(s -> pagingQueryList.add("fields." + key + "=" + LaFunctions.u(s))));
        });
        form.as.entrySet().stream().filter(e -> e.getValue() != null).forEach(e -> {

            return file.exists();
        }

        @Override
        public void forEach(final ClassHandler handler) {
            ClassTraversalUtil.forEach(baseDir, rootPackage, handler);
        }

        @Override
        public void forEach(final ResourceHandler handler) {
            ResourceTraversalUtil.forEach(baseDir, rootDir, handler);
        }

        @Override
        public void close() {

        final String key = ComponentUtil.getVirtualHostHelper().getVirtualHostKey();
        keywordList.stream().forEach(keyword -> {
            final List<Tuple3<String, QueryBuilder, ScoreFunctionBuilder<?>>> boostList = getQueryMap(key).get(toLowerCase(keyword));
            if (boostList != null) {
                boostList.forEach(pair -> list.add(new FilterFunctionBuilder(pair.getValue2(), pair.getValue3())));
            }
        });
    }

        if (resolveReportLocationsOnAdd) {
            reportLocations.forEach { it.resolve() }
        }
        taskPathToReports.merge(taskPath, reportLocations, { prev, next -> prev + next })
    }

    fun onTaskGraphReady() {
        resolveReportLocationsOnAdd = true
        taskPathToReports.values.asSequence()
            .flatMap { it }
            .forEach { it.resolve() }
    }

                if (parameters.getNoCache().get()) {
                    spec.args("--no-cache");
                }

                parameters.getTags().get().forEach(tag -> spec.args("--tag", tag));

                parameters.getBuildArgs().get().forEach((k, v) -> spec.args("--build-arg", k + "=" + v));
            });

            try {
                parameters.getMarkerFile().getAsFile().get().createNewFile();

        builder.setSourcepath(validSourcepath.files.toTypedArray())

        val builtJar = builder.build()
        if (!builder.isOk) {
          builder.getErrors().forEach { task.logger.error("Error: $it") }
          builder.getWarnings().forEach { task.logger.warn("Warning: $it") }
          throw GradleException("Bundle $archiveFileName has errors")
        }

        builtJar.write(archiveFile)

        model.stages
            .filter { it.stageName <= StageName.READY_FOR_RELEASE }
            .flatMap { it.functionalTests }
            .filter { it.os == os && !it.testType.crossVersionTests }
            .forEach {
                buildType(FlakyTestQuarantine(model, stage, it))
            }

        model.stages
            .filter { it.stageName <= StageName.READY_FOR_RELEASE }

     * <p>
     * If a root package is specified at instance construction, only classes under the root package are targeted.
     * </p>
     *
     * @param handler the handler to process classes
     */
    void forEach(ClassHandler handler);

    /**
     * Searches for resources handled by this instance and calls the handler for each resource.
     * <p>