Gets the available application domains.

@param serviceCallback the async ServiceCallback to handle successful and failed responses.
@throws IllegalArgumentException thrown if parameters fail the validation
@return the {@link ServiceFuture} object
165188
public ServiceFuture<List<String>> listDomainsAsync(final ServiceCallback<List<String>> serviceCallback) {
        return ServiceFuture.fromResponse(listDomainsWithServiceResponseAsync(), serviceCallback);
    }
1365615
public ServiceFuture<CertificateBundle> getCertificateAsync(String certificateIdentifier,
            final ServiceCallback<CertificateBundle> serviceCallback) {
        CertificateIdentifier id = new CertificateIdentifier(certificateIdentifier);
        return getCertificateAsync(id.vault(), id.name(), id.version() == null ? "" : id.version(), serviceCallback);
    }
14542
public Observable<ServiceResponse<List<String>>> listDomainsWithServiceResponseAsync() {
        if (this.client.endpoint() == null) {
            throw new IllegalArgumentException("Parameter this.client.endpoint() is required and cannot be null.");
        }
        String parameterizedHost = Joiner.on(", ").join("{Endpoint}", this.client.endpoint());
        return service.listDomains(this.client.acceptLanguage(), parameterizedHost, this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<List<String>>>>() {
                @Override
                public Observable<ServiceResponse<List<String>>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<List<String>> clientResponse = listDomainsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
866624
public static String serviceName(Class<?> serviceInterface) {
    // Service name
    Service serviceAnnotation = serviceInterface.getAnnotation(Service.class);
    if (serviceAnnotation == null) {
      throw new IllegalArgumentException(
          String.format("Not a service interface: %s", serviceInterface));
    }
    return serviceAnnotation.value().length() > 0
        ? serviceAnnotation.value()
        : serviceInterface.getName();
  }
1155753
public Observable<ServiceResponse<ApplicationInfoResponse>> getWithServiceResponseAsync(UUID appId) {
        if (this.client.endpoint() == null) {
            throw new IllegalArgumentException("Parameter this.client.endpoint() is required and cannot be null.");
        }
        if (appId == null) {
            throw new IllegalArgumentException("Parameter appId is required and cannot be null.");
        }
        String parameterizedHost = Joiner.on(", ").join("{Endpoint}", this.client.endpoint());
        return service.get(appId, this.client.acceptLanguage(), parameterizedHost, this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<ApplicationInfoResponse>>>() {
                @Override
                public Observable<ServiceResponse<ApplicationInfoResponse>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<ApplicationInfoResponse> clientResponse = getDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
133816
public java.util.List<? extends com.google.appengine.v1.ServiceOrBuilder> 
      getServicesOrBuilderList() {
    return services_;
  }
957667
public Observable<List<Domain>> getDomainsAsync() {
        return getDomainsWithServiceResponseAsync().map(new Func1<ServiceResponse<List<Domain>>, List<Domain>>() {
            @Override
            public List<Domain> call(ServiceResponse<List<Domain>> response) {
                return response.body();
            }
        });
    }
328291
public Object getService(TargetMetaDef targetMetaDef) {

    Debug.logVerbose("[JdonFramework] --> enter getService from dynamicProxy", module);

    Object dynamicProxy = _proxyCache.get(targetMetaDef);
    if (dynamicProxy == null) {
      dynamicProxy = getServiceFromProxy(targetMetaDef);
      _proxyCache.put(targetMetaDef, dynamicProxy);
    }
    return dynamicProxy;

  }
369055
public static dnsaction[] get(nitro_service service) throws Exception{
		dnsaction obj = new dnsaction();
		dnsaction[] response = (dnsaction[])obj.get_resources(service);
		return response;
	}
175650
public ServiceFuture<List<UserSubscriptionQuotaInner>> listAsync(final ServiceCallback<List<UserSubscriptionQuotaInner>> serviceCallback) {
        return ServiceFuture.fromResponse(listWithServiceResponseAsync(), serviceCallback);
    }
254672
public static vpnglobal_domain_binding[] get(nitro_service service) throws Exception{
		vpnglobal_domain_binding obj = new vpnglobal_domain_binding();
		vpnglobal_domain_binding response[] = (vpnglobal_domain_binding[]) obj.get_resources(service);
		return response;
	}
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);
                    }
                }
            });
    }
961716
public Observable<Page<ApplicationGatewayInner>> listAllAsync() {
        return listAllWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<ApplicationGatewayInner>>, Page<ApplicationGatewayInner>>() {
                @Override
                public Page<ApplicationGatewayInner> call(ServiceResponse<Page<ApplicationGatewayInner>> response) {
                    return response.body();
                }
            });
    }
10125
public ServiceFuture<List<PolicyDefinitionInner>> listBuiltInAsync(final ListOperationCallback<PolicyDefinitionInner> serviceCallback) {
        return AzureServiceFuture.fromPageResponse(
            listBuiltInSinglePageAsync(),
            new Func1<String, Observable<ServiceResponse<Page<PolicyDefinitionInner>>>>() {
                @Override
                public Observable<ServiceResponse<Page<PolicyDefinitionInner>>> call(String nextPageLink) {
                    return listBuiltInNextSinglePageAsync(nextPageLink);
                }
            },
            serviceCallback);
    }
241240
public Service getService(AppContextWrapper sc) {
		ContainerWrapper containerWrapper = containerFinder.findContainer(sc);
		Service service = (Service) containerWrapper.lookup(ComponentKeys.WEBSERVICE);
		return service;
	}
814198
@Override
    public Publisher<List<String>> getServiceIds() {
        ServiceFilter serviceFilter = new ServiceFilter().withName("NAMESPACE_ID").withValues(getRoute53ClientDiscoveryConfiguration().getNamespaceId());
        ListServicesRequest listServicesRequest = new ListServicesRequest().withFilters(serviceFilter);
        Future<ListServicesResult> response = getDiscoveryClient().listServicesAsync(listServicesRequest);
        Flowable<ListServicesResult> flowableList = Flowable.fromFuture(response);
        return flowableList.flatMap(this::convertServiceIds);
    }
189320
@Override
  public AnnotatedType api()
  {
    ServiceRefAmp delegate = delegate();
    
    if (delegate == null) {
      System.out.println("FAILED_DELEGATE: " + this);
    }
    
    return delegate().api();
  }