return serviceRegistry.get(serviceType);
        }

        @Override
        public <T> List<T> getAll(Class<T> serviceType) throws ServiceLookupException {
            return serviceRegistry.getAll(serviceType);
        }

        @Override
        public Object get(Type serviceType) throws UnknownServiceException, ServiceLookupException {

/**
 * Provides access to existing daemons.
 *
 * Implementations should be thread-safe.
 */
@ThreadSafe
@ServiceScope(Scope.Global.class)
public interface DaemonRegistry {

    List<DaemonInfo> getAll();
    List<DaemonInfo> getIdle();
    List<DaemonInfo> getNotIdle();
    List<DaemonInfo> getCanceled();

    void store(DaemonInfo info);
    void remove(Address address);

     */
    @Nullable Service getFactory(Class<?> type);

    /**
     * Collects all services of the given type.
     *
     * @return A visitor that should be used for all subsequent services.
     */
    Visitor getAll(Class<?> serviceType, Visitor visitor);

    interface Visitor {
        void visit(Service service);
    }

import javax.annotation.Nullable;
import java.util.List;

@ServiceScope(Scope.Global.class)
public interface ServiceLocator {
    <T> T get(Class<T> serviceType) throws UnknownServiceException;

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

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

    @Nullable

import java.util.Collections;
import java.util.List;
import java.util.Optional;

public class RequestExtrasContainer {
    private final List<RequestExtra> extras = new ArrayList<>();

    public List<RequestExtra> getAll() {
        return Collections.unmodifiableList(extras);
    }

    public <T> Optional<T> getByType(Class<T> type) {
        return Cast.uncheckedCast(extras.stream().filter(type::isInstance).findFirst());
    }

                    fileLockManager),
                DaemonRegistryContent.SERIALIZER,
                chmod
            ));
    }

    @Override
    public List<DaemonInfo> getAll() {
        lock.lock();
        try {
            DaemonRegistryContent content = cache.get();
            if (content == null) {
                //when no daemon process has started yet

        registry = new EmbeddedDaemonRegistry()
    }

    DaemonInfo registerDaemon(DaemonStateControl.State state, long lastIdle = -1) {
        final String uid = UUID.randomUUID().toString()
        final int id = registry.getAll().size() + 1
        final long lastIdleTime = lastIdle == -1L ? id * 1000 : lastIdle;
        Address daemonAddress = createAddress(id)
        DaemonContext context = Mock(DaemonContext) {
            _ * getUid() >> uid

	fmtp, _ := syscall.BytePtrFromString("%d %d %d")
	a, _, _ := GetDLL(t, "user32.dll").Proc("wsprintfA").Call(
		uintptr(unsafe.Pointer(&buf[0])),
		uintptr(unsafe.Pointer(fmtp)),
		1000, 2000, 3000)
	if string(buf[:a]) != "1000 2000 3000" {
		t.Error("cdecl USER32.wsprintfA returns", a, "buf=", buf[:a])
	}
}

func TestEnumWindows(t *testing.T) {
	d := GetDLL(t, "user32.dll")
	isWindows := d.Proc("IsWindow")
	counter := 0

        List<GradleModuleServices> servicesProviders = new DefaultServiceLocator(classLoaderRegistry.getRuntimeClassLoader(), classLoaderRegistry.getPluginsClassLoader()).getAll(GradleModuleServices.class);
        for (GradleModuleServices services : servicesProviders) {
            registration.add(GradleModuleServices.class, services);
            services.registerGlobalServices(registration);

// explaining why.
//
//go:nosplit
func debugCallCheck(pc uintptr) string {
	// No user calls from the system stack.
	if getg() != getg().m.curg {
		return debugCallSystemStack
	}
	if sp := getcallersp(); !(getg().stack.lo < sp && sp <= getg().stack.hi) {
		// Fast syscalls (nanotime) and racecall switch to the
		// g0 stack without switching g. We can't safely make