*/
@ThreadSafe
public class DefaultConfigurationFactory {

    private final Instantiator instantiator;
    private final ConfigurationResolver resolver;
    private final ListenerManager listenerManager;
    private final DependencyMetaDataProvider metaDataProvider;
    private final ComponentIdentifierFactory componentIdentifierFactory;
    private final DependencyLockingProvider dependencyLockingProvider;

import org.gradle.internal.event.ListenerManager;

public class PendingChangesManager {
    private final ListenerManager listenerManager;

    public PendingChangesManager(ListenerManager listenerManager) {
        this.listenerManager = listenerManager;
    }

    public void addListener(PendingChangesListener listener) {
        listenerManager.addListener(listener);
    }

        }

        GradleInternal gradle = buildScopeServices.get(GradleInternal.class);
        ListenerManager listenerManager = buildScopeServices.get(ListenerManager.class);

        BuildModelController buildModelController = buildScopeServices.get(BuildModelController.class);
        InternalProblems problems = buildScopeServices.get(InternalProblems.class);

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 {
        listenerManager.addListener(this)
    }

    public DefaultFileContentCacheFactory(ListenerManager listenerManager, FileSystemAccess fileSystemAccess, ScopedCacheBuilderFactory cacheBuilderFactory, InMemoryCacheDecoratorFactory inMemoryCacheDecoratorFactory) {
        this.listenerManager = listenerManager;
        this.fileSystemAccess = fileSystemAccess;
        this.inMemoryCacheDecoratorFactory = inMemoryCacheDecoratorFactory;

    private final ClassLoaderHierarchyHasher classLoaderHierarchyHasher;
    private final ExecutionEngine executionEngine;
    private final InputFingerprinter inputFingerprinter;
    private final ListenerManager listenerManager;
    private final ReservedFileSystemLocationRegistry reservedFileSystemLocationRegistry;
    private final FileCollectionFactory fileCollectionFactory;
    private final TaskDependencyFactory taskDependencyFactory;

    public WorkerDaemonClientsManager(WorkerDaemonStarter workerDaemonStarter, ListenerManager listenerManager, LoggingManagerInternal loggingManager, MemoryManager memoryManager, OsMemoryInfo memoryInfo) {
        this.workerDaemonStarter = workerDaemonStarter;
        this.listenerManager = listenerManager;
        this.loggingManager = loggingManager;
        this.memoryInfo = memoryInfo;

 */
@ThreadSafe
public class DefaultCrossBuildInMemoryCacheFactory implements CrossBuildInMemoryCacheFactory {
    private final ListenerManager listenerManager;

    public DefaultCrossBuildInMemoryCacheFactory(ListenerManager listenerManager) {
        this.listenerManager = listenerManager;
    }

    @Override
    public <K, V> CrossBuildInMemoryCache<K, V> newCache() {

public class DefaultWorkInputListeners implements WorkInputListeners {
    private final AnonymousListenerBroadcast<WorkInputListener> broadcaster;

    public DefaultWorkInputListeners(ListenerManager listenerManager) {
        broadcaster = listenerManager.createAnonymousBroadcaster(WorkInputListener.class);
    }

    @Override
    public void addListener(WorkInputListener listener) {
        broadcaster.add(listener);
    }

    private final InternalOptions options;
    private final FeatureFlagListener broadcaster;

    public DefaultFeatureFlags(InternalOptions options, ListenerManager listenerManager) {
        this.options = options;
        this.broadcaster = listenerManager.getBroadcaster(FeatureFlagListener.class);
    }

    @Override
    public boolean isEnabled(FeatureFlag flag) {
        broadcaster.flagRead(flag);