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
    <T> DefaultServiceLocator.ServiceFactory<T> findFactory(Class<T> serviceType);

    }

    protected ProjectDependencyInternal create(String path) {
        return (ProjectDependencyInternal) factory.create(finder.getProject(path));
    }

    protected TypeSafeProjectDependencyFactory getFactory() {
        return this;
    }

     * @throws UnknownServiceException When there is no factory available for services of the given type.
     * @throws ServiceLookupException On failure to lookup the specified service factory.
     */
    <T> Factory<T> getFactory(Class<T> type) throws UnknownServiceException, ServiceLookupException;

    /**
     * Creates a new service instance of the given type.
     *
     * @param type The service type
     * @param <T>  The service type.

      mlir::cast<mlir::vhlo::TensorV1Attr>(pad_op.getEdgePaddingLow()),
      vhlo_type_converter));
  auto edge_padding_high = builder_.CreateVector(mlir::GetVector<int64_t>(
      mlir::cast<mlir::vhlo::TensorV1Attr>(pad_op.getEdgePaddingHigh()),
      vhlo_type_converter));
  auto interior_padding = builder_.CreateVector(mlir::GetVector<int64_t>(

    /**
     * Creates a factory for creating views of this rule source, for invoking rules or binding references. Should be used only before the rule source has been applied.
     */
    Factory<? extends T> getFactory();

    static {
        singletonRegistry = new ConnectorServiceRegistry();
    }

    public static DefaultGradleConnector createConnector() {
        return singletonRegistry.getFactory(DefaultGradleConnector.class).create();
    }

    public static CancellationTokenSource createCancellationTokenSource() {
        return new DefaultCancellationTokenSource();
    }

    public static void close() {

    @Nullable Service getService(Type serviceType);

    /**
     * Locates a factory for services of the given type. Returns null if this provider does not provide any services of this type.
     */
    @Nullable Service getFactory(Class<?> type);

    /**
     * Collects all services of the given type.
     *
     * @return A visitor that should be used for all subsequent services.
     */

        this.useCaches = useCaches;
        this.classLoaders = Arrays.asList(classLoaders);
    }

    @Override
    public <T> T get(Class<T> serviceType) throws UnknownServiceException {
        return getFactory(serviceType).create();
    }

    @Override
    public <T> List<T> getAll(Class<T> serviceType) throws UnknownServiceException {
        List<ServiceFactory<T>> factories = findFactoriesForServiceType(serviceType);

namespace tensorflow {
namespace {

class XlaHostSendRecvDeviceContextTest : public ::testing::Test {
 public:
  void SetDevice(const string& device_type) {
    auto device_factory = DeviceFactory::GetFactory(device_type);
    SessionOptions options;
    std::vector<std::unique_ptr<Device>> devices;
    Status s = device_factory->CreateDevices(
        options, "/job:worker/replica:0/task:0", &devices);

        }
        List<T> all = delegate.getAll(serviceType);
        allServices.put(serviceType, all);
        return all;
    }

    @Override
    public synchronized <T> DefaultServiceLocator.ServiceFactory<T> getFactory(Class<T> serviceType) throws UnknownServiceException {
        DefaultServiceLocator.ServiceFactory<T> factory = findFactory(serviceType);
        if (factory == null) {