Gets a list of compute operations.

@param serviceCallback the async ServiceCallback to handle successful and failed responses.
@throws IllegalArgumentException thrown if parameters fail the validation
@return the {@link ServiceFuture} object
967130
public ServiceFuture<List<ComputeOperationValueInner>> listAsync(final ServiceCallback<List<ComputeOperationValueInner>> serviceCallback) {
        return ServiceFuture.fromResponse(listWithServiceResponseAsync(), serviceCallback);
    }
738988
@Override
    public <T> ListResult<T> list(EntityListOperation<T> lister)
            throws ServiceException {
        try {
            return service.list(lister);
        } catch (UniformInterfaceException e) {
            throw processCatch(new ServiceException(e));
        } catch (ClientHandlerException e) {
            throw processCatch(new ServiceException(e));
        }
    }
839330
@Override
	public List<Object> getServices(Class<?> root,Class<?> transactionType){
		Map<Class<?>, List<Object>> map = mapBusinessProvider.get(root);
		if(map != null){
			List<Object> list = map.get(transactionType);
			if(list != null){
				return Collections.unmodifiableList(list);
			}
		}
		return null;
	}
1353989
ComputeService jcloudContext( Map<String,String> targetProperties ) throws TargetException {

		validate( targetProperties );
		ComputeServiceContext context = ContextBuilder
				.newBuilder( targetProperties.get( PROVIDER_ID ))
				.endpoint( targetProperties.get( ENDPOINT ))
				.credentials( targetProperties.get( IDENTITY ), targetProperties.get( CREDENTIAL ))
				.buildView( ComputeServiceContext.class );

		return context.getComputeService();
	}
253548
public ServiceFuture<SkuInfosInner> listSkusAsync(final ServiceCallback<SkuInfosInner> serviceCallback) {
        return ServiceFuture.fromResponse(listSkusWithServiceResponseAsync(), serviceCallback);
    }
731855
@Override
    public <T> T get(EntityGetOperation<T> getter) throws ServiceException {
        try {
            return service.get(getter);
        } catch (UniformInterfaceException e) {
            throw processCatch(new ServiceException(e));
        } catch (ClientHandlerException e) {
            throw processCatch(new ServiceException(e));
        }
    }
496234
public Observable<ServiceResponse<List<ImageList>>> getAllImageListsWithServiceResponseAsync() {
        if (this.client.baseUrl() == null) {
            throw new IllegalArgumentException("Parameter this.client.baseUrl() is required and cannot be null.");
        }
        String parameterizedHost = Joiner.on(", ").join("{baseUrl}", this.client.baseUrl());
        return service.getAllImageLists(this.client.acceptLanguage(), parameterizedHost, this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<List<ImageList>>>>() {
                @Override
                public Observable<ServiceResponse<List<ImageList>>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<List<ImageList>> clientResponse = getAllImageListsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
341169
public ServiceFuture<List<ClusterInner>> listAsync(final ServiceCallback<List<ClusterInner>> serviceCallback) {
        return ServiceFuture.fromResponse(listWithServiceResponseAsync(), serviceCallback);
    }
884268
public ServiceFuture<List<CognitiveServicesAccountInner>> listAsync(final ServiceCallback<List<CognitiveServicesAccountInner>> serviceCallback) {
        return ServiceFuture.fromResponse(listWithServiceResponseAsync(), serviceCallback);
    }
361291
static <E> List<E> getListFromFutures(List<Future<E>> futures) {
		List<E> list = new ArrayList<E>();
		for (Future<E> f : futures) {
			// TODO when added to ConcurrencyTools, log completions and exceptions instead of printing stack traces
			try {
				list.add(f.get());
			} catch (InterruptedException e) {
				logger.error("Interrupted Exception: ", e);
			} catch (ExecutionException e) {
				logger.error("Execution Exception: ", e);
			}
		}
		return list;
	}
1366395
public Observable<Page<CloudPool>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponseWithHeaders<Page<CloudPool>, PoolListHeaders>, Page<CloudPool>>() {
                @Override
                public Page<CloudPool> call(ServiceResponseWithHeaders<Page<CloudPool>, PoolListHeaders> response) {
                    return response.body();
                }
            });
    }
717242
public static <T> List<T> getServices(Class<T> intf) {
        List<T> ret = new ArrayList<T>();

        for (T service : ServiceLoader.load(intf)) {
            if (!(service instanceof ServiceStatus) || ((ServiceStatus)service).isAvailable()) {
                if (service instanceof ServiceLifecycle) {
                    ((ServiceLifecycle)service).init();
                }

                ret.add(service);
            }
        }

        return ret;
    }
193237
public Observable<Page<AppServiceCertificateOrderInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<AppServiceCertificateOrderInner>>, Page<AppServiceCertificateOrderInner>>() {
                @Override
                public Page<AppServiceCertificateOrderInner> call(ServiceResponse<Page<AppServiceCertificateOrderInner>> response) {
                    return response.body();
                }
            });
    }
175650
public ServiceFuture<List<UserSubscriptionQuotaInner>> listAsync(final ServiceCallback<List<UserSubscriptionQuotaInner>> serviceCallback) {
        return ServiceFuture.fromResponse(listWithServiceResponseAsync(), serviceCallback);
    }
553675
public Observable<ServiceResponse<ApplicationGatewayAvailableSslOptionsInner>> listAvailableSslOptionsWithServiceResponseAsync() {
        if (this.client.subscriptionId() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionId() is required and cannot be null.");
        }
        final String apiVersion = "2018-06-01";
        return service.listAvailableSslOptions(this.client.subscriptionId(), apiVersion, this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<ApplicationGatewayAvailableSslOptionsInner>>>() {
                @Override
                public Observable<ServiceResponse<ApplicationGatewayAvailableSslOptionsInner>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<ApplicationGatewayAvailableSslOptionsInner> clientResponse = listAvailableSslOptionsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
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;
    }
1368901
public ServiceFuture<List<AvailableCulture>> listSupportedCulturesAsync(final ServiceCallback<List<AvailableCulture>> serviceCallback) {
        return ServiceFuture.fromResponse(listSupportedCulturesWithServiceResponseAsync(), serviceCallback);
    }