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 {
    /**

 */

package org.gradle.internal.work;

import org.gradle.internal.concurrent.Stoppable;

/**
 * Represents a queue of executions that can run when a provided resource lock can be acquired.  The typical use case would
 * be that a worker lease must be acquired before execution.
 */
public interface ConditionalExecutionQueue<T> extends Stoppable {
    /**

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.launcher.daemon.server;

import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.remote.Address;

/**
 * Opens a server connection for clients to connect to communicate with a daemon.
 * <p>

import org.gradle.cache.FileLockManager;
import org.gradle.cache.IndexedCache;
import org.gradle.cache.PersistentCache;
import org.gradle.cache.scopes.BuildTreeScopedCacheBuilderFactory;
import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Serializer;
import org.gradle.vcs.git.internal.GitVersionRef;

            }
        }
    }

    override fun stop() {
        val stoppable = CompositeStoppable.stoppable()
        stoppable.addIfInitialized(lazyBuildTreeModelSideEffects)
        stoppable.addIfInitialized(lazyIntermediateModels)
        stoppable.addIfInitialized(lazyProjectMetadata)
        stoppable.add(store)
        stoppable.stop()
    }

    private

 * limitations under the License.
 */

package org.gradle.workers.internal;

import org.gradle.api.NonNullApi;
import org.gradle.initialization.BuildCancellationToken;
import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import java.util.concurrent.atomic.AtomicBoolean;

/**

import org.gradle.cache.CleanupFrequency;
import org.gradle.cache.internal.DefaultCleanupProgressMonitor;
import org.gradle.cache.internal.VersionSpecificCacheCleanupAction;
import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.file.Deleter;
import org.gradle.internal.operations.BuildOperationContext;
import org.gradle.internal.operations.BuildOperationDescriptor;
import org.gradle.internal.operations.BuildOperationRunner;

import org.gradle.execution.EntryTaskSelector;
import org.gradle.execution.plan.QueryableExecutionPlan;
import org.gradle.internal.concurrent.Stoppable;

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

public interface BuildWorkGraph extends Stoppable {
    /**
     * Schedules the given tasks and all of their dependencies in this work graph.
     */

package org.gradle.language.cpp.internal;

import org.gradle.cache.FileLockManager;
import org.gradle.cache.PersistentCache;
import org.gradle.cache.scopes.GlobalScopedCacheBuilderFactory;
import org.gradle.internal.concurrent.Stoppable;
import org.gradle.nativeplatform.internal.modulemap.ModuleMap;

import java.io.File;

import static org.gradle.nativeplatform.internal.modulemap.GenerateModuleMapFile.generateFile;

/**