* limitations under the License.
 */

package org.gradle.internal.dispatch;

import org.gradle.internal.concurrent.Stoppable;
import org.slf4j.Logger;

public class ExceptionTrackingFailureHandler implements DispatchFailureHandler<Object>, Stoppable {
    private final Logger logger;
    private DispatchException failure;

    public ExceptionTrackingFailureHandler(Logger logger) {

import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.work.ConditionalExecutionQueue;
import org.gradle.internal.work.ConditionalExecutionQueueFactory;

import javax.annotation.Nullable;
import javax.annotation.concurrent.ThreadSafe;

@ThreadSafe
public class WorkerExecutionQueueFactory implements Factory<ConditionalExecutionQueue<DefaultWorkResult>>, Stoppable {

import org.gradle.api.logging.Logging;
import org.gradle.initialization.BuildCancellationToken;
import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.dispatch.Dispatch;
import org.gradle.launcher.daemon.protocol.Cancel;

public class DaemonCancelForwarder implements Stoppable {
    private static final Logger LOGGER = Logging.getLogger(DaemonCancelForwarder.class);

    private final Runnable cancellationCallback;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.tooling.internal.provider;

import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.launcher.daemon.client.DaemonStartListener;
import org.gradle.launcher.daemon.client.DaemonStopClient;

import org.gradle.api.Task;
import org.gradle.api.specs.Spec;
import org.gradle.execution.EntryTaskSelector;
import org.gradle.internal.concurrent.Stoppable;

import java.util.function.BiConsumer;
import java.util.function.Consumer;

public interface BuildWorkPlan extends Stoppable {
    /**
     * Invokes the given action when a task completes (as per {@link Node#isComplete()}). Does nothing for tasks that have already completed.
     */

import org.gradle.api.Describable;
import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.operations.BuildOperationRef;

import javax.annotation.Nullable;
import java.time.Duration;

/**
 * Manages timeouts for threads, interrupting them if the timeout is exceeded.
 */
public interface TimeoutHandler extends Stoppable {
    /**

 * limitations under the License.
 */

package org.gradle.process.internal;

import org.gradle.internal.concurrent.Stoppable;

import java.util.concurrent.Executor;

public interface StreamsHandler extends Stoppable {
    /**
     * Collects whatever state is required the given process. Should not start work.
     */

import org.gradle.internal.concurrent.CompositeStoppable;
import org.gradle.internal.concurrent.ExecutorFactory;
import org.gradle.internal.concurrent.ManagedExecutor;
import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.concurrent.ThreadSafe;
import org.gradle.internal.dispatch.AsyncDispatch;
import org.gradle.internal.dispatch.Dispatch;
import org.gradle.internal.dispatch.DispatchException;

import org.gradle.internal.concurrent.Stoppable
import org.gradle.internal.event.ListenerManager
import org.gradle.kotlin.dsl.support.disposeKotlinCompilerContext


/**
 * Disposes Kotlin compiler environment once all scripts are compiled.
 */
internal
class KotlinCompilerContextDisposer(
    private val listenerManager: ListenerManager
) : InternalBuildAdapter(), Stoppable {

    init {

import org.gradle.internal.concurrent.Stoppable;

import javax.annotation.Nullable;
import java.lang.reflect.Type;

/**
 * Provides a set of zero or more services. The get-methods may be called concurrently. {@link #stop()} is guaranteed to be only called once,
 * after all get-methods have completed.
 */
interface ServiceProvider extends Stoppable {
    /**