Get {@link TaskState}s of {@link Task}s of this job.

@return a list of {@link TaskState}s
348382
public List<TaskState> getTaskStates() {
    return ImmutableList.<TaskState>builder().addAll(this.taskStates.values()).build();
  }
1349124
public @Nonnull List<String> getJobs() {
        List<String> r = new ArrayList<>();
        r.addAll(usages.keySet());
        Collections.sort(r);
        return r;
    }
1332515
public List<RemoteTask> getAllTasks()
    {
        return tasks.values().stream()
                .flatMap(Set::stream)
                .collect(toImmutableList());
    }
285163
protected static Iterable<AgentTask> getTaskList(List<WeakReference<AgentTask>> tasks) {
		final Iterable<AgentTask> col = Iterables.transform(tasks, it -> it != null ? it.get() : null);
		return Iterables.filter(col, it -> it != null);
	}
149360
List<CommitTaskAction> getCommitActions(TaskTrackerStatus tts) {
    synchronized (lockObject) {
      List<CommitTaskAction> saveList = new ArrayList<CommitTaskAction>();
      List<TaskStatus> taskStatuses = tts.getTaskReports();
      if (taskStatuses != null) {
        for (TaskStatus taskStatus : taskStatuses) {
          if (taskStatus.getRunState() == TaskStatus.State.COMMIT_PENDING) {
            TaskAttemptID taskId = taskStatus.getTaskID();
            TaskInProgress tip = taskLookupTable.getTIP(taskId);
            if (tip == null) {
              continue;
            }
            if (tip.shouldCommit(taskId)) {
              CommitTaskAction commitAction = new CommitTaskAction(taskId);
              saveList.add(commitAction);
              LOG.debug(tts.getTrackerName() +
                  " -> CommitTaskAction: " + taskId);
            }
          }
        }
      }
      return saveList;
    }
  }
1204007
public int getCompletedTasks() {
    int completedTasks = 0;
    for (TaskState taskState : this.taskStates.values()) {
      if (taskState.isCompleted()) {
        completedTasks++;
      }
    }

    return completedTasks;
  }
324186
public static List<KeyedStateHandle> getKeyedStateHandles(
		Collection<? extends KeyedStateHandle> keyedStateHandles,
		KeyGroupRange subtaskKeyGroupRange) {

		List<KeyedStateHandle> subtaskKeyedStateHandles = new ArrayList<>(keyedStateHandles.size());

		for (KeyedStateHandle keyedStateHandle : keyedStateHandles) {
			KeyedStateHandle intersectedKeyedStateHandle = keyedStateHandle.getIntersection(subtaskKeyGroupRange);

			if (intersectedKeyedStateHandle != null) {
				subtaskKeyedStateHandles.add(intersectedKeyedStateHandle);
			}
		}

		return subtaskKeyedStateHandles;
	}
1193707
public synchronized List<TaskStatus> getNonRunningTasks() {
    List<TaskStatus> result = new ArrayList<TaskStatus>(tasks.size());
    for(Map.Entry<TaskAttemptID, TaskInProgress> task: tasks.entrySet()) {
      if (!runningTasks.containsKey(task.getKey())) {
        result.add(task.getValue().getStatus());
      }
    }
    return result;
  }
312350
public List<TaskAction> getCustomActions()
    throws ServiceException, DataAccessException {

        CodeTimer timer = new CodeTimer("getCustomActions()", true);
        List<TaskAction> dynamicTaskActions = new ArrayList<TaskAction>();

        try {
            ActivityInstance activityInstance = getActivityInstance(true);

            if (activityInstance != null) {
                Long processInstanceId = activityInstance.getProcessInstanceId();
                ProcessInstance processInstance = ServiceLocator.getWorkflowServices().getProcess(processInstanceId);
                Process processVO = null;
                if (processInstance.getProcessInstDefId() > 0L)
                    processVO = ProcessCache.getProcessInstanceDefiniton(processInstance.getProcessId(), processInstance.getProcessInstDefId());
                if (processVO == null)
                    processVO = ProcessCache.getProcess(processInstance.getProcessId());
                if (processInstance.isEmbedded())
                    processVO = processVO.getSubProcessVO(new Long(processInstance.getComment()));
                List<Transition> outgoingWorkTransVOs = processVO.getAllTransitions(activityInstance.getActivityId());
                for (Transition workTransVO : outgoingWorkTransVOs) {
                    String resultCode = workTransVO.getCompletionCode();
                    if (resultCode != null) {
                        Integer eventType = workTransVO.getEventType();
                        if (eventType.equals(EventType.FINISH) || eventType.equals(EventType.RESUME) || TaskAction.FORWARD.equals(resultCode)) {
                            TaskAction taskAction = new TaskAction();
                            taskAction.setTaskActionName(resultCode);
                            taskAction.setCustom(true);
                            dynamicTaskActions.add(taskAction);
                        }
                    }
                }
            }
        }
        catch (Exception ex) {
            logger.severeException(ex.getMessage(), ex);
        }
        timer.stopAndLogTiming("");
        return dynamicTaskActions;
    }
275370
public Collection<Task> getTasks(TaskFilter filter) {
        filter = (filter != null) ? filter : new TaskFilter();

        return getInstance().get().tasks(getFilter(filter, false));
    }
903207
public static State getReefTaskState(final CloudTask task) {
    switch (task.state()) {
    case ACTIVE:
      return State.INIT;
    case RUNNING:
      return State.RUNNING;
    case COMPLETED:
      if (task.executionInfo().result() == TaskExecutionResult.SUCCESS) {
        return State.DONE;
      } else {
        return State.FAILED;
      }
    case PREPARING:
      return State.RUNNING;
    default:
      throw new IllegalArgumentException("Azure batch cloud task has unknown state: " + task.state());
    }
  }
16945
public CompletableFuture<Collection<JobStatusMessage>> listJobs() {
		return runDispatcherCommand(dispatcherGateway ->
			dispatcherGateway
				.requestMultipleJobDetails(rpcTimeout)
				.thenApply(jobs ->
					jobs.getJobs().stream()
						.map(details -> new JobStatusMessage(details.getJobId(), details.getJobName(), details.getStatus(), details.getStartTime()))
						.collect(Collectors.toList())));
	}
1126379
public static synchronized List<String> getTaskList() {
        List<String> tasks;

        if (uploadTasksMap.isEmpty()) {
            tasks = new ArrayList<>(1);
        } else {
            tasks = new ArrayList<>(uploadTasksMap.size());
            tasks.addAll(uploadTasksMap.keySet());
        }

        return tasks;
    }
496967
public CompositeOperation<TaskExecution> getTasks() {
        List<TaskExecution> taskExecutions = CollectionUtils.sort(tasks.values(), slowestFirst());
        return new CompositeOperation<TaskExecution>(taskExecutions);
    }
619423
public java.util.List<ECSTaskSet> getTaskSetsInfo() {
        if (taskSetsInfo == null) {
            taskSetsInfo = new com.amazonaws.internal.SdkInternalList<ECSTaskSet>();
        }
        return taskSetsInfo;
    }
681958
public java.util.List<InstanceState> getInstanceStates() {
        if (instanceStates == null) {
            instanceStates = new com.amazonaws.internal.SdkInternalList<InstanceState>();
        }
        return instanceStates;
    }
86281
public <T> JobStatus<T> getJobStatus(JobStatus<T> status) {
        return complete(getJobStatusAsync(status));
    }