}

    @Override
    public boolean isProcessPlugins() {
        return request.isProcessPlugins();
    }

    @Override
    public FilterModelBuildingRequest setProcessPlugins(boolean processPlugins) {
        request.setProcessPlugins(processPlugins);

        return this;
    }

    @Override
    public boolean isTwoPhaseBuilding() {
        return request.isTwoPhaseBuilding();
    }

    @Override

        setPomFile(request.getPomFile());
        setModelSource(request.getModelSource());
        setValidationLevel(request.getValidationLevel());
        setProcessPlugins(request.isProcessPlugins());
        setTwoPhaseBuilding(request.isTwoPhaseBuilding());
        setLocationTracking(request.isLocationTracking());
        setProfiles(request.getProfiles());

                    .setRepositorySession(session.getSession())
                    .setRemoteRepositories(repositories)
                    .setPluginArtifactRepositories(repositories)
                    .setProcessPlugins(request.isProcessPlugins());
            ProjectBuildingResult res;
            if (request.getPath().isPresent()) {
                Path path = request.getPath().get();

     *
     * @param processPlugins {@code true} to enable plugin processing, {@code false} otherwise.
     * @return This request, never {@code null}.
     */
    ModelBuildingRequest setProcessPlugins(boolean processPlugins);

    /**
     * Indicates whether the model building should happen in two phases. If enabled, the initial invocation of the model

        ModelBuilder builder = new DefaultModelBuilderFactory().newInstance();
        assertNotNull(builder);

        DefaultModelBuildingRequest request = new DefaultModelBuildingRequest();
        request.setProcessPlugins(true);
        request.setPomFile(getPom("simple"));

        ModelBuildingResult result = builder.build(request);
        assertNotNull(result);
        assertNotNull(result.getEffectiveModel());

        ModelBuilder builder = new DefaultModelBuilderFactory().newInstance();
        assertNotNull(builder);

        DefaultModelBuildingRequest request = new DefaultModelBuildingRequest();
        request.setProcessPlugins(true);
        request.setPomFile(getPom("complex"));
        request.setSystemProperties(sysProperties);

        ModelBuildingResult result = builder.build(request);
        assertNotNull(result);

        ProjectBuildingRequest request = injectSession(toRequest(configuration));
        request.setRemoteRepositories(normalizeToArtifactRepositories(remoteRepositories, request));
        request.setProcessPlugins(false);
        request.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL);

        try {
            return projectBuilder.build(artifact, allowStubModel, request).getProject();

        configuration.setLocalRepository(getLocalRepository());
        configuration.setRemoteRepositories(Arrays.asList(new ArtifactRepository[] {}));
        configuration.setProcessPlugins(true);
        configuration.setResolveDependencies(true);
        initRepoSession(configuration);

        try {
            return projectBuilder.build(pom, configuration).getProject();

                ModelBuildingRequest modelRequest = new DefaultModelBuildingRequest();
                modelRequest.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL);
                modelRequest.setProcessPlugins(false);
                modelRequest.setTwoPhaseBuilding(false);
                // This merge is on purpose because otherwise user properties would override model

                    configuration.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL);
                    configuration.setProcessPlugins(false);
                    configuration.setRepositoryMerging(ProjectBuildingRequest.RepositoryMerging.REQUEST_DOMINANT);
                    MavenSession session = legacySupport.getSession();