// Expire recently unused Daemons when memory pressure is high
        addLowMemoryDaemonExpirationStrategyWhenSupported(daemon, strategies, listenerManager);

        // Expire when Daemon Registry becomes unreachable for some reason
        strategies.add(new DaemonRegistryUnavailableExpirationStrategy(daemon));

        this.strategy = new AnyDaemonExpirationStrategy(strategies.build());
    }

     */
    void kill();

    /**
     * Forcefully kills this daemon, but not child processes.
     */
    void killDaemonOnly();

    /**
     * Changes the authentication token for this daemon in the registry, so that client will see a different token to that expected by this daemon
     */
    void changeTokenVisibleToClient();

    void assertRegistryNotWorldReadable();

    /**

import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.util.Path;

import javax.annotation.Nullable;
import javax.annotation.concurrent.ThreadSafe;
import java.util.Collection;

/**
 * A registry of all projects present in a build tree.
 */
@ThreadSafe
@ServiceScope(Scope.BuildTree.class)
public interface ProjectStateRegistry {
    /**
     * Returns all projects in the build tree.
     */

import org.gradle.internal.snapshot.SnapshotHierarchy;
import org.gradle.internal.watch.registry.FileWatcherProbeRegistry;
import org.gradle.internal.watch.registry.FileWatcherUpdater;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.util.Collection;
import java.util.List;

/**
 * Updater for hierarchical file watchers.
 *

import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;

/**
 * A Gradle user home level registry of {@link ToPlannedNodeConverter} instances.
 * <p>
 * All the available converters are expected to support disjoint set of {@link Node node types}.
 */
@NonNullApi
@ThreadSafe
@ServiceScope(Scope.UserHome.class)

        InstrumentationTypeRegistry registry = getInstrumentationTypeRegistry();

        InstrumentationDependencyAnalysis data = serializer.readDependencyAnalysis(input);
        Map<String, Set<String>> dependenciesSuperTypes = new TreeMap<>();
        for (String className : data.getDependencies().keySet()) {
            Set<String> superTypes = registry.getSuperTypes(className);
            if (!superTypes.isEmpty()) {

import org.gradle.api.artifacts.component.ProjectComponentIdentifier;
import org.gradle.internal.component.local.model.LocalComponentGraphResolveState;

import javax.annotation.concurrent.ThreadSafe;

/**
 * A registry of all dependency resolution state for locally produced components.
 * These components may be produced within the same project, another project in the same multi-project build,
 * or in another build within a composite.
 */

 * limitations under the License.
 */

package org.gradle.internal.service;

import org.gradle.api.NonNullApi;
import org.gradle.internal.service.scopes.Scope;

/**
 * A registry validating that all registered services are annotated with a corresponding {@link Scope}.
 */
@NonNullApi
public class ScopedServiceRegistry extends DefaultServiceRegistry {

    public ScopedServiceRegistry(

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.model.internal.registry;

import com.google.common.base.Optional;
import org.gradle.model.RuleSource;
import org.gradle.model.internal.core.ChainingModelProjection;
import org.gradle.model.internal.core.EmptyModelProjection;

import org.gradle.launcher.daemon.diagnostics.DaemonDiagnostics;
import org.gradle.launcher.daemon.protocol.DaemonMessageSerializer;
import org.gradle.launcher.daemon.registry.DaemonDir;
import org.gradle.launcher.daemon.registry.DaemonRegistry;
import org.gradle.launcher.daemon.server.api.DaemonCommandAction;
import org.gradle.launcher.daemon.server.api.HandleInvalidateVirtualFileSystem;