}
    }

    private <T> List<ServiceFactory<T>> findFactoriesForServiceType(Class<T> serviceType) {
        return factoriesFor(serviceType, implementationsOf(serviceType));
    }

    private <T> List<ServiceFactory<T>> factoriesFor(Class<T> serviceType, List<Class<? extends T>> implementationClasses) {
        List<ServiceFactory<T>> factories = new ArrayList<ServiceFactory<T>>();

@ServiceScope(Scope.Global.class)
public class CachingServiceLocator implements ServiceLocator {
    private final ServiceLocator delegate;
    private final Map<Class<?>, DefaultServiceLocator.ServiceFactory<?>> serviceFactories = new HashMap<Class<?>, DefaultServiceLocator.ServiceFactory<?>>();
    private final Map<Class<?>, Object> services = new HashMap<Class<?>, Object>();
    private final Map<Class<?>, List<?>> allServices = new HashMap<Class<?>, List<?>>();

     *
     * @param pluginMetadata any information provided by the plugin to Gradle
     * @param serviceFactory a factory for a per-build-invocation service for the plugin
     */
    GradleEnterprisePluginCheckInResult checkIn(
        GradleEnterprisePluginMetadata pluginMetadata,
        GradleEnterprisePluginServiceFactory serviceFactory
    );

    <T> List<T> getAll(Class<T> serviceType) throws UnknownServiceException;

    <T> DefaultServiceLocator.ServiceFactory<T> getFactory(Class<T> serviceType) throws UnknownServiceException;

    @Nullable
    <T> DefaultServiceLocator.ServiceFactory<T> findFactory(Class<T> serviceType);

    @Override
    public GradleEnterprisePluginCheckInResult checkIn(GradleEnterprisePluginMetadata pluginMetadata, GradleEnterprisePluginServiceFactory serviceFactory) {
        if (Boolean.getBoolean(UNSUPPORTED_TOGGLE)) {
            return checkInUnsupportedResult(UNSUPPORTED_TOGGLE_MESSAGE);
        }

        String pluginVersion = pluginMetadata.getVersion();

                        return
                    }

                    def pluginMetadata = { -> "$runtimeVersion" } as $GradleEnterprisePluginMetadata.name
                    def serviceFactory = {
                        $GradleEnterprisePluginConfig.name config,
                        $GradleEnterprisePluginRequiredServices.name requiredServices,

    }

    void register(String className, String loadBody, String storeBody) {
        settingsFile << """
            class ${className} extends AbstractBuildCache {}
            class ${className}ServiceFactory implements BuildCacheServiceFactory<${className}> {
                ${className}Service createBuildCacheService(${className} configuration, Describer describer) {
                    return new ${className}Service(configuration)