* limitations under the License.
 */

package org.gradle.workers;

/**
 * A worker spec providing the requirements of a forked process with a custom classpath.
 *
 * @since 5.6
 */
public interface ProcessWorkerSpec extends ForkingWorkerSpec, ClassLoaderWorkerSpec {

    }

    @TaskAction
    void reverseFiles() {
        // tag::worker-daemon[]
        // Create a WorkQueue with process isolation
        WorkQueue workQueue = workerExecutor.processIsolation() { ProcessWorkerSpec spec ->
            // Configure the options for the forked process
            forkOptions { JavaForkOptions options ->
                options.maxHeapSize = "512m"

import org.gradle.process.JavaForkOptions;
import org.gradle.workers.ClassLoaderWorkerSpec;
import org.gradle.workers.ProcessWorkerSpec;

import javax.inject.Inject;
import java.util.Map;
import java.util.regex.Pattern;

public class DefaultProcessWorkerSpec extends DefaultClassLoaderWorkerSpec implements ProcessWorkerSpec, ClassLoaderWorkerSpec {
    /**
     * Environment variables inherited automatically on Unix systems.
     *

        if (configuration instanceof ProcessWorkerSpec) {
            DaemonForkOptionsBuilder builder = new DaemonForkOptionsBuilder(forkOptionsFactory)
                .keepAliveMode(KeepAliveMode.SESSION);
            ProcessWorkerSpec processConfiguration = (ProcessWorkerSpec) configuration;
            JavaForkOptions forkOptions = forkOptionsFactory.newJavaForkOptions();

     *
     * Work will execute in an idle daemon matching the requirements specified in the supplied {@link ProcessWorkerSpec}, if available.  If no idle daemons are available, a new daemon will be started.
     *
     * @since 5.6
     */
    WorkQueue processIsolation(Action<? super ProcessWorkerSpec> action);

    /**

This process can be configured with different settings than the Gradle JVM using link:{javadocPath}/org/gradle/workers/ProcessWorkerSpec.html#forkOptions-org.gradle.api.Action-[ProcessWorkerSpec.forkOptions(org.gradle.api.Action)].

[[worker-daemons]]
=== Worker Daemons

     *
     * Execution of the work may begin immediately.
     *
     * Work submitted using {@link WorkerExecutor#processIsolation()} will execute in an idle daemon that meets the requirements set
     * in the {@link ProcessWorkerSpec}.  If no idle daemons are available, a new daemon will be started.  Any errors
     * will be thrown from {@link #await()} or from the surrounding task action if {@link #await()} is not used.
     */

                        if (spec instanceof ClassLoaderWorkerSpec) {
                            classpath.from(additionalClasspath)
                        }
                        if (spec instanceof ProcessWorkerSpec) {
                            forkOptions.maxHeapSize = "64m"
                            forkOptions(additionalForkOptions)
                        }
                        if (this.forkMode != null) {

                    return workerExecutor."\${isolationMode}"({ config ->
                        if (config instanceof ProcessWorkerSpec) {
                            config.forkOptions.maxHeapSize = "64m"
                            config.forkOptions(additionalForkOptions)
                        }

                        public void run() {
                            try {
                                workerExecutor.${workerMethod}({ config ->
                                    if (config instanceof ProcessWorkerSpec) {
                                        forkOptions.maxHeapSize = "64m"
                                        forkOptions(additionalForkOptions)
                                    }