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

package org.gradle.internal.watch.registry;

import java.io.File;
import java.util.stream.Stream;

/**
 * A registry of watch probes. A probe serves as a way to prove that a hierarchy Gradle is interested in
 * indeed receives file system events from the operating system.

import org.gradle.internal.file.FileType;
import org.gradle.internal.snapshot.SnapshotHierarchy;
import org.gradle.internal.watch.registry.FileWatcherProbeRegistry;
import org.gradle.internal.watch.registry.FileWatcherUpdater;

import java.io.File;
import java.util.Collection;
import java.util.concurrent.BlockingQueue;
import java.util.function.Predicate;

        DefaultServiceRegistry registry = scope != null
            ? new ScopedServiceRegistry(scope, strict, displayName, parents)
            : new DefaultServiceRegistry(displayName, parents);

        for (ServiceRegistrationProvider provider : providers) {
            registry.addProvider(provider);
        }
        return registry;
    }

        return new DefaultCapturingServicesRegistry(registrar);
    }

    private class DefaultCapturingServicesRegistry implements ServiceRegistry {
        private final ImplicitInputRecorder registrar;

        private DefaultCapturingServicesRegistry(ImplicitInputRecorder registrar) {
            this.registrar = registrar;
        }

        @Override

     * arbitrary user types.
     */
    <T> void useJavaSerialization(Class<T> implementationType);

    /**
     * Returns true when this registry can serialize objects of the given type.
     */
    boolean canSerialize(Class<?> baseType);

    /**
     * Creates a serializer that uses the current registrations to serialize objects of type T.
     */

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

package org.gradle.language.nativeplatform.internal.registry;

import org.gradle.internal.service.ServiceRegistration;
import org.gradle.internal.service.scopes.AbstractGradleModuleServices;
import org.gradle.language.cpp.internal.NativeDependencyCache;

package org.gradle.internal.scripts;

import org.gradle.scripts.ScriptingLanguage;

import javax.annotation.Nullable;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * Registry of scripting languages.
 */
public final class ScriptingLanguages {

    private static final List<ScriptingLanguage> ALL =
        Collections.unmodifiableList(
            Arrays.asList(

     */
    Collection<? extends ResourceLock> getResourceLocksByCurrentThread();

    /**
     * Returns true if the registry has any locks that are being held by a thread.
     *
     * @return true if any locks in the registry are currently held.
     */
    boolean hasOpenLocks();

    }

    public static class ToolingModelRegistration implements BuildScopeToolingModelBuilderRegistryAction {
        @Override
        public void execute(ToolingModelBuilderRegistry registry) {
            registry.register(new CppModelBuilder());
        }
    }

 * limitations under the License.
 */

package org.gradle.model.internal.inspect;

import org.gradle.internal.Factory;
import org.gradle.model.internal.core.MutableModelNode;
import org.gradle.model.internal.registry.ModelRegistry;

import java.util.List;

public interface ExtractedRuleSource<T> {
    /**
     * Applies the rules of this rule source to the given element.
     */