Lists all of the jobs in the specified account.

@param jobListOptions Additional parameters for the operation
@throws IllegalArgumentException thrown if parameters fail the validation
@return the observable to the PagedList&lt;CloudJob&gt; object
516395
public Observable<ServiceResponseWithHeaders<Page<CloudJob>, JobListHeaders>> listWithServiceResponseAsync(final JobListOptions jobListOptions) {
        return listSinglePageAsync(jobListOptions)
            .concatMap(new Func1<ServiceResponseWithHeaders<Page<CloudJob>, JobListHeaders>, Observable<ServiceResponseWithHeaders<Page<CloudJob>, JobListHeaders>>>() {
                @Override
                public Observable<ServiceResponseWithHeaders<Page<CloudJob>, JobListHeaders>> call(ServiceResponseWithHeaders<Page<CloudJob>, JobListHeaders> page) {
                    String nextPageLink = page.body().nextPageLink();
                    if (nextPageLink == null) {
                        return Observable.just(page);
                    }
                    JobListNextOptions jobListNextOptions = null;
                    if (jobListOptions != null) {
                        jobListNextOptions = new JobListNextOptions();
                        jobListNextOptions.withClientRequestId(jobListOptions.clientRequestId());
                        jobListNextOptions.withReturnClientRequestId(jobListOptions.returnClientRequestId());
                        jobListNextOptions.withOcpDate(jobListOptions.ocpDate());
                    }
                    return Observable.just(page).concatWith(listNextWithServiceResponseAsync(nextPageLink, jobListNextOptions));
                }
            });
    }
827220
List<Job> getRemainingJobs() {
    if (mThread.isAlive()) {
      LOG.warn("Internal error: Polling running monitor for jobs");
    }
    synchronized (mJobs) {
      return new ArrayList<Job>(mJobs);
    }
  }
988761
public Observable<Page<ServiceEndpointPolicyInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<ServiceEndpointPolicyInner>>, Page<ServiceEndpointPolicyInner>>() {
                @Override
                public Page<ServiceEndpointPolicyInner> call(ServiceResponse<Page<ServiceEndpointPolicyInner>> response) {
                    return response.body();
                }
            });
    }
694689
public List<CloudTask> getTaskStatusForJob(final String jobId) {
    List<CloudTask> tasks = null;
    try {
      tasks = client.taskOperations().listTasks(jobId);
      LOG.log(Level.INFO, "Task status for job: {0} returned {1} tasks", new Object[]{jobId, tasks.size()});
    } catch (IOException | BatchErrorException ex) {
      LOG.log(Level.SEVERE, "Exception when fetching Task status for job: {0}. Exception [{1}]:[2]",
          new Object[]{jobId, ex.getMessage(), ex.getStackTrace()});
    }

    return tasks;
  }
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();
                }
            });
    }
1116972
@Override
    public List<JobExecutionEntity> getJobExecutionsFromJobInstanceId(long jobInstanceId) throws NoSuchJobInstanceException {

        JobInstanceEntity instance = getJobInstance(jobInstanceId);
        List<JobExecutionEntity> executions = new ArrayList<JobExecutionEntity>(instance.getJobExecutions());

        // sorting could be optimized a bit but is it necessary for this impl?
        Collections.sort(executions, ReverseJobExecutionSequenceForOneInstanceComparator.INSTANCE);

        return executions;
    }
215165
public Observable<Page<PoolNodeCounts>> listPoolNodeCountsAsync() {
        return listPoolNodeCountsWithServiceResponseAsync()
            .map(new Func1<ServiceResponseWithHeaders<Page<PoolNodeCounts>, AccountListPoolNodeCountsHeaders>, Page<PoolNodeCounts>>() {
                @Override
                public Page<PoolNodeCounts> call(ServiceResponseWithHeaders<Page<PoolNodeCounts>, AccountListPoolNodeCountsHeaders> response) {
                    return response.body();
                }
            });
    }
451391
public Page<Job> listJobs() {
    // [START bigquery_list_jobs]
    Page<Job> jobs = bigquery.listJobs(JobListOption.pageSize(100));
    for (Job job : jobs.iterateAll()) {
      // do something with the job
    }
    // [END bigquery_list_jobs]
    return jobs;
  }
775459
public Observable<Page<OperationInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<OperationInner>>, Page<OperationInner>>() {
                @Override
                public Page<OperationInner> call(ServiceResponse<Page<OperationInner>> response) {
                    return response.body();
                }
            });
    }
650482
@GET
  @Produces(APPLICATION_JSON)
  @Timed
  @ExceptionMetered
  public Map<JobId, Job> list(
      @QueryParam("q") @DefaultValue("") final String query,
      @QueryParam("hostPattern") @DefaultValue("") final String hostPattern) {

    final Map<JobId, Job> allJobs;
    if (!hostPattern.isEmpty()) {
      // for each host that matches this pattern...
      allJobs = model.listHosts(hostPattern).stream()
          // get the host status
          .map(model::getHostStatus)
          // then flat map over the jobs deployed to this host
          .flatMap(hostStatus -> hostStatus.getJobs().keySet().stream())
          .distinct()
          .collect(Collectors.toMap(Function.identity(), model::getJob));
    } else {
      allJobs = model.getJobs();
    }

    // Return all jobs if the query string is empty
    if (query.isEmpty()) {
      metrics.jobsInJobList(allJobs.size());
      return allJobs;
    }

    // Filter jobs by jobname query
    final Map<JobId, Job> filteredJobs = Maps.newHashMap();
    for (final Map.Entry<JobId, Job> entry : allJobs.entrySet()) {
      if (entry.getKey().toString().contains(query)) {
        filteredJobs.put(entry.getKey(), entry.getValue());
      }
    }

    metrics.jobsInJobList(filteredJobs.size());
    return filteredJobs;
  }
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();
                }
            });
    }
343695
public Observable<Page<ProviderInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<ProviderInner>>, Page<ProviderInner>>() {
                @Override
                public Page<ProviderInner> call(ServiceResponse<Page<ProviderInner>> response) {
                    return response.body();
                }
            });
    }
940802
public static void printJobProperties(Optional<JobExecutionInfo> jobExecutionInfoOptional) {
        if (!jobExecutionInfoOptional.isPresent()) {
            System.err.println("Job not found.");
            return;
        }
        List<List<String>> data = new ArrayList<>();
        List<String> flags = Arrays.asList("", "-");
        List<String> labels = Arrays.asList("Property Key", "Property Value");

        for (Map.Entry<String, String> entry : jobExecutionInfoOptional.get().getJobProperties().entrySet()) {
            data.add(Arrays.asList(entry.getKey(), entry.getValue()));
        }

        new CliTablePrinter.Builder()
                .labels(labels)
                .data(data)
                .flags(flags)
                .delimiterWidth(2)
                .build()
                .printTable();
    }
1122202
public Observable<ServiceResponse<PersonalAssistantsResponse>> listCortanaEndpointsWithServiceResponseAsync() {
        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.listCortanaEndpoints(this.client.acceptLanguage(), parameterizedHost, this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<PersonalAssistantsResponse>>>() {
                @Override
                public Observable<ServiceResponse<PersonalAssistantsResponse>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<PersonalAssistantsResponse> clientResponse = listCortanaEndpointsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
28863
@Override
    public List<JobInstance> getJobs(Query query)
    {
        return JqmClientFactory.getClient().getJobs(query);
    }
158860
public Observable<OperationListResultInner> listAsync() {
        return listWithServiceResponseAsync().map(new Func1<ServiceResponse<OperationListResultInner>, OperationListResultInner>() {
            @Override
            public OperationListResultInner call(ServiceResponse<OperationListResultInner> response) {
                return response.body();
            }
        });
    }
585459
public Observable<Page<InterfaceEndpointInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<InterfaceEndpointInner>>, Page<InterfaceEndpointInner>>() {
                @Override
                public Page<InterfaceEndpointInner> call(ServiceResponse<Page<InterfaceEndpointInner>> response) {
                    return response.body();
                }
            });
    }