Delegate method for {@link ServiceProvider#getServices(Class)}.

@param serviceType the service type.
@return the services found.
@see ServiceProvider#getServices(Class)
519004
public static <T> Collection<T> getServices(Class<T> serviceType) {
        return getServiceProvider().getServices(serviceType);
    }
262981
public ServiceFuture<List<Domain>> getDomainsAsync(final ServiceCallback<List<Domain>> serviceCallback) {
        return ServiceFuture.fromResponse(getDomainsWithServiceResponseAsync(), serviceCallback);
    }
133816
public java.util.List<? extends com.google.appengine.v1.ServiceOrBuilder> 
      getServicesOrBuilderList() {
    return services_;
  }
580948
public java.util.List<String> getServiceNames() {
        if (serviceNames == null) {
            serviceNames = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return serviceNames;
    }
396830
@Override
    public List<ServiceInfo> getServiceInfos(Class serviceClass) {
        final LinkedList<ServiceInfo> result = new LinkedList<ServiceInfo>();
        for (ServiceInfo serviceInfo : services.values()) {
            if (serviceInfo.isInstanceOf(serviceClass)) {
                if (serviceInfo.isCoreService()) {
                    result.addFirst(serviceInfo);
                } else {
                    result.addLast(serviceInfo);
                }
            }
        }
        return result;
    }
347953
public static <C, T extends Service<C>> ServiceBuilder<C, T> forService(
            Class<T> serviceType) {

        if (serviceType == null) {
            throw new NullPointerException("serviceType");
        }

        V1ServiceInterface v1annotation =
                serviceType.getAnnotation(V1ServiceInterface.class);

        if (v1annotation != null) {
            return new ServiceBuilder<>(
                    new V1ServiceFactory<>(serviceType, v1annotation));
        }

        CustomServiceInterface customAnnotation =
                serviceType.getAnnotation(CustomServiceInterface.class);

        if (customAnnotation != null) {
            return new ServiceBuilder<>(
                    new CustomServiceFactory<>(serviceType, customAnnotation));
        }

        throw new IllegalArgumentException(
                "Service interfaces must be decorated with an "
                + "@[Type]ServiceInterface annotation.");
    }
199154
public alluxio.grpc.ServiceType getServiceType() {
    alluxio.grpc.ServiceType result = alluxio.grpc.ServiceType.valueOf(serviceType_);
    return result == null ? alluxio.grpc.ServiceType.UNKNOWN_SERVICE : result;
  }
188940
@Deprecated
    public static List<Service> getServices(String type,
            List<String> algorithms) {
        ProviderList list = Providers.getProviderList();
        return list.getServices(type, algorithms);
    }
557322
public static <T> List<T> load(ClassLoader classLoader, Class<T> serviceType) {
        List<T> foundServices = new ArrayList<>();
        Iterator<T> iterator = ServiceLoader.load(serviceType, classLoader).iterator();

        while (checkHasNextSafely(iterator)) {
            try {
                T item = iterator.next();
                foundServices.add(item);
                LOGGER.debug(String.format("Found %s [%s]", serviceType.getSimpleName(), item.toString()));
            } catch (ServiceConfigurationError e) {
                LOGGER.trace("Can't find services using Java SPI", e);
                LOGGER.error(e.getMessage());
            }
        }
        return foundServices;
    }
885711
@Override
  public <T> ServiceBuilder service(Class<T> type)
  {
    Key<?> key = Key.of(type, ServiceImpl.class);

    return service(key, type);
  }
641515
public List<ServiceRefHandlerType<ServiceRefType<T>>> getAllHandler()
   {
      List<ServiceRefHandlerType<ServiceRefType<T>>> list = new ArrayList<ServiceRefHandlerType<ServiceRefType<T>>>();
      List<Node> nodeList = childNode.get("handler");
      for(Node node: nodeList)
      {
         ServiceRefHandlerType<ServiceRefType<T>>  type = new ServiceRefHandlerTypeImpl<ServiceRefType<T>>(this, "handler", childNode, node);
         list.add(type);
      }
      return list;
   }
491652
private IBatchServiceBase getService(Name serviceType) throws BatchContainerServiceException {
        String sourceMethod = "getService";
        if (logger.isLoggable(Level.FINE))
            logger.entering(sourceClass, sourceMethod + ", serviceType=" + serviceType);

        initIfNecessary();

        IBatchServiceBase service = new ServiceLoader(serviceType).getService();

        if (logger.isLoggable(Level.FINE))
            logger.exiting(sourceClass, sourceMethod);

        return service;
    }
1336186
public java.util.List<String> getServiceArns() {
        if (serviceArns == null) {
            serviceArns = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return serviceArns;
    }
527932
@SuppressWarnings("unchecked")
	public static <T> List<T> getInstanceList(Class<T> type) {
		if (type == null) {
			throw new IllegalArgumentException("Type should not be empty");
		}

		List<T> loader = (List<T>) EXTENSION_LOCATOR.get(type);
		if (loader == null) {
			try {
				lock.lock();
				List<T> instanceList = new ArrayList<T>();
				ServiceLoader<T> serviceLoader = ServiceLoader.load(type);
				for (T service : serviceLoader) {
					instanceList.add(service);
				}
				loader = instanceList;
				if (EXTENSION_LOCATOR.putIfAbsent(type, instanceList) != instanceList) {
					loader = (List<T>) EXTENSION_LOCATOR.get(type);
				}
			} catch (Exception e) {
				LOG.error("Error to load SPI instances from META-INF/services/" + type, e);
			} finally {
				lock.unlock();
			}
		}
		return loader;
	}
443851
private <T> List<T> loadServices(final Class<T> serviceType) {
        List<T> services = new ArrayList<>();
        try {
            for (T t : ServiceLoader.load(serviceType)) {
                services.add(t);
            }
            services.sort(Comparator.comparing(o -> o.getClass().getSimpleName()));
            @SuppressWarnings("unchecked")
            final List<T> previousServices = (List<T>) servicesLoaded.putIfAbsent(serviceType, (List<Object>) services);
            return Collections.unmodifiableList(previousServices != null ? previousServices : services);
        } catch (Exception e) {
            Logger.getLogger(DefaultServiceProvider.class.getName()).log(Level.WARNING,
                                                                         "Error loading services of type " + serviceType, e);
            return services;
        }
    }
233083
@Override
    public <T> Collection<T> all(Class<T> serviceClass) {

        if (serviceClass == null) {
            throw new IllegalArgumentException("ServiceClass must be provided");
        }

        return createInstances(serviceClass, load(serviceClass));
    }
331157
public List<ServiceMonitor> getServiceMonitors() {
        List<ServiceMonitor> serviceMonitors = new ArrayList<>();
        serviceMonitors.addAll(getDynamicServices(ServiceMonitor.class));
        return serviceMonitors;
    }