Gets the task historical events.

@return the task historical events
340197
public List<TaskHistoricalEvent> getHistoricalEvents() {
        List<TaskHistoricalEvent> result = new ArrayList<TaskHistoricalEvent>();
        List<TaskHistoricalEventType> historicalEventTypes = getContent()
                .getHistoricalEventTypes();

        if (historicalEventTypes != null) {
            for (TaskHistoricalEventType taskHistoricalEventType : historicalEventTypes) {
                String message = taskHistoricalEventType.getMessage();
                if ((message != null) && (message.isEmpty())) {
                    message = null;
                }
                TaskHistoricalEvent taskHistoricalEvent = new TaskHistoricalEvent(
                        taskHistoricalEventType.getCode(), message,
                        taskHistoricalEventType.getTimeStamp());
                result.add(taskHistoricalEvent);
            }
        }

        return result;
    }
619423
public java.util.List<ECSTaskSet> getTaskSetsInfo() {
        if (taskSetsInfo == null) {
            taskSetsInfo = new com.amazonaws.internal.SdkInternalList<ECSTaskSet>();
        }
        return taskSetsInfo;
    }
745318
public static ftw_events[] get(nitro_service client) throws Exception
	{
		ftw_events resource = new ftw_events();
		resource.validate("get");
		return (ftw_events[]) resource.get_resources(client);
	}
417676
public java.util.List<VolumeStatusEvent> getEvents() {
        if (events == null) {
            events = new com.amazonaws.internal.SdkInternalList<VolumeStatusEvent>();
        }
        return events;
    }
522812
public Date getFinishDate()
   {
      Date finishDate = null;

      for (Task task : m_tasks)
      {
         //
         // If a hidden "summary" task is present we ignore it
         //
         if (NumberHelper.getInt(task.getUniqueID()) == 0)
         {
            continue;
         }

         //
         // Select the actual or forecast start date
         //
         Date taskFinishDate;
         taskFinishDate = task.getActualFinish();
         if (taskFinishDate == null)
         {
            taskFinishDate = task.getFinish();
         }

         if (taskFinishDate != null)
         {
            if (finishDate == null)
            {
               finishDate = taskFinishDate;
            }
            else
            {
               if (taskFinishDate.getTime() > finishDate.getTime())
               {
                  finishDate = taskFinishDate;
               }
            }
         }
      }

      return (finishDate);
   }
943184
public List<T> getEvents() {
        List<T> returnEvents = new ArrayList<T>();

        if (bufferedEvents.isEmpty()) {
            return returnEvents;
        }

        int returnSize = isBufferFull() ? bufferSize : bufferedEvents.size();

        for (int i = 0 ; i < returnSize ; i++) {
            returnEvents.add(bufferedEvents.remove(0));
        }

        return returnEvents;
    }
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;
    }
973883
public LruList<LoggingEvent> getEvents() {
        if (events == null) {
            events = new LruList<LoggingEvent>(LoggingEvent.class, getSize());
        }
        return events;
    }
684964
synchronized List<TaskStatus> getRunningTaskStatuses() {
    List<TaskStatus> result = new ArrayList<TaskStatus>(runningTasks.size());
    for(TaskInProgress tip: runningTasks.values()) {
      result.add(tip.getStatus());
    }
    return result;
  }
654353
public Optional<SingularityTaskHistory> getHistoryForTask(String taskId) {
    final Function<String, String> requestUri = (host) -> String.format(TASK_HISTORY_FORMAT, getApiBase(host), taskId);

    return getSingle(requestUri, "task history", taskId, SingularityTaskHistory.class);
  }
1054201
List<EventInfo> getEvents() {
        synchronized (events) {
            List<EventInfo> result = new ArrayList<>(events.size());
            for (ListIterator<EventInfo> iterator = events.listIterator(events.size()); iterator.hasPrevious();) {
                result.add(iterator.previous());
            }
            return result;
        }
    }
553687
public java.util.List<EventSubscription> getEventSubscriptionsList() {
        if (eventSubscriptionsList == null) {
            eventSubscriptionsList = new com.amazonaws.internal.SdkInternalList<EventSubscription>();
        }
        return eventSubscriptionsList;
    }
975051
public static List<TaskAction> getMyTasksBulkActions() throws IOException, XmlException {
        if (myTasksBulkActions == null) {
            myTasksBulkActions = new ArrayList<TaskAction>();
            for (AllowableAction allowableAction : getTaskActions().getBulkTaskActions().getAssignedBulkActions().getAllowableActionList()) {
                TaskAction taskAction = convertToJsonable(allowableAction);
                if (!myTasksBulkActions.contains(taskAction))
                    myTasksBulkActions.add(taskAction);
            }
        }
        return myTasksBulkActions;
    }
910202
public java.util.List<String> getEventCategories() {
        if (eventCategories == null) {
            eventCategories = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return eventCategories;
    }
399578
public java.util.List<EventTopic> getEventTopics() {
        if (eventTopics == null) {
            eventTopics = new com.amazonaws.internal.SdkInternalList<EventTopic>();
        }
        return eventTopics;
    }
658596
public synchronized List<WorkManagerEvent> getEvents(String workManagerName)
   {
      List<WorkManagerEvent> result = new ArrayList<WorkManagerEvent>();
      List<WorkManagerEvent> e = events.get(workManagerName);

      if (e != null)
      {
         result.addAll(e);
         e.clear();
      }

      if (trace)
         log.tracef("getEvents(%s): %s", workManagerName, result);

      return result;
   }
877158
public java.util.List<LifecycleEvent> getLifecycleEvents() {
        if (lifecycleEvents == null) {
            lifecycleEvents = new com.amazonaws.internal.SdkInternalList<LifecycleEvent>();
        }
        return lifecycleEvents;
    }