import java.io.File


/**
 * A scheduler of IO actions.
 */
interface IO {

    /**
     * Schedules the given [io action][action] for execution.
     *
     * The effect of an IO [action] is only guaranteed to be observable
     * by a subsequent [io] action or after the [closing][IOScope.close] of
     * the current [IOScope].
     */
    fun io(action: () -> Unit)
}


/**

import org.gradle.api.Action;
import org.gradle.process.internal.worker.WorkerProcessContext;

import java.io.Serializable;
import java.util.Arrays;
import java.util.List;

public class LoggingProcess implements Action<WorkerProcessContext>, Serializable {

    private final List<SerializableLogAction> actions;

    public LoggingProcess(SerializableLogAction... actions){

        "actions.set(0, anAction)"                                  | "Task.getActions().set(int, Object)"
        "actions.removeAll(actions)"                                | "Task.getActions().removeAll()"
        "actions.remove(actions[0])"                                | "Task.getActions().remove()"

    def "can configure classpath with Actions"() {
        given:
        def xmlTransformer = Mock(XmlTransformer)
        def xmlMerger = Spy(XmlFileContentMerger, constructorArgs: [xmlTransformer])
        def xmlAction = {} as Action<XmlProvider>
        model.classpath.file = xmlMerger

        when: "configure classpath"
        model.classpath({ cp -> cp.downloadJavadoc = true } as Action<EclipseClasspath>)

        then:

    /**
     * Applies the given action to each item of the given type in this collection, as each item is required.
     *
     * <p>The given action is invoked to configure the item when the item is required. It is called before any actions provided to {@link #create(String, org.gradle.api.Action)}.
     *
     * @param type The type of elements to apply the action to.

     */
    def <T> Action<T> serializable(Action<T> action, ClassLoader target) {
        String src = """
class TestAction implements ${Action.class.name}, ${Serializable.class.name}
{
    Object key

    void execute(Object target) {
        def action = ${SerializableMockHelper.class.name}.ACTIONS.remove(key)
        action.execute(target)
    }
}
"""

 * <p>
 * The given actions will be executed in the order given to the constructor, and should use the {@link #proceed()} method to allow
 * the next action to run. If an action does not call {@code proceed()}, it will be the last action that executes.
 */
public class DaemonCommandExecution {

      stream.requestBody.use {
        stream.responseBody.use {
          while (true) {
            val action = actions.poll() ?: break
            action(stream)
          }
        }
      }
      return@FutureTask null
    }
  }

  /** Returns once all stream actions complete successfully. */
  fun awaitSuccess() {
    val futureTask =
      results.poll(5, TimeUnit.SECONDS)

        attributesMutator = GUtil.elvis(attributesMutator, Actions.doNothing());
        capabilitiesMutator = GUtil.elvis(capabilitiesMutator, Actions.doNothing());

        if (delegate instanceof DefaultMinimalDependencyVariant) {
            this.attributesMutator = Actions.composite(((DefaultMinimalDependencyVariant) delegate).attributesMutator, attributesMutator);

                        details.notFound();
                    }
                }
            };
            if (filter == Actions.doNothing()) {
                return action;
            }
            return Actions.composite(filter, action);
        }
        return filter;
    }

    @Override
    public RepositoryContentDescriptorInternal asMutableCopy() {