Returns the compact representations of all of the dependencies of a task.

@param  task The task to get dependencies on.
@return Request object
540827
public ItemRequest<Task> dependencies(String task) {
    
        String path = String.format("/tasks/%s/dependencies", task);
        return new ItemRequest<Task>(this, Task.class, path, "GET");
    }
823146
private String extractAndConvertTaskType(Task task)
   {
      String activityType = (String) task.getCachedValue(m_activityTypeField);
      if (activityType == null)
      {
         activityType = "Resource Dependent";
      }
      else
      {
         if (ACTIVITY_TYPE_MAP.containsKey(activityType))
         {
            activityType = ACTIVITY_TYPE_MAP.get(activityType);
         }
      }
      return activityType;
   }
843858
@Override
	public List<String> getDelcaredDependencies(String mid) throws ProcessingDependenciesException {
		List<String> result = null;
		try {
			getReadLock();
			try {
				DepTreeNode.DependencyInfo depInfo = depMap.get(mid);
				if (depInfo != null) {
					result = depInfo.getDeclaredDependencies();
				}
			} finally {
				releaseReadLock();
			}
		} catch (InterruptedException e) {
			if (log.isLoggable(Level.SEVERE)) {
				log.log(Level.SEVERE, e.getMessage(), e);
			}
		}
		return result;
	}
836826
function (requestObject) {
            var dependencies = [], appEnv = ariaModulesUrlServiceEnvironmentUrlService;
            if (!requestObject.urlService && !this._urlService) {
                var urlServiceCfg = appEnv.getUrlServiceCfg();
                dependencies.push(urlServiceCfg.implementation);
            }
            if (!requestObject.requestHandler && !this._requestHandler) {
                var requestHandlerCfg = ariaModulesRequestHandlerEnvironmentRequestHandler.getRequestHandlerCfg();
                dependencies.push(requestHandlerCfg.implementation);
            }
            return dependencies;
        }
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;
    }
679243
public static Map getComponentMap(DefaultTopologyAssignContext context, Integer task) {
        String componentName = context.getTaskToComponent().get(task);
        ComponentCommon componentCommon = ThriftTopologyUtils.getComponentCommon(context.getSysTopology(), componentName);

        Map componentMap = (Map) JStormUtils.from_json(componentCommon.get_json_conf());
        if (componentMap == null) {
            componentMap = Maps.newHashMap();
        }
        return componentMap;
    }
1343795
private static TaskEntity getTask(final int taskId, final Collection<TaskEntity> tasks) {
    for (final TaskEntity task : tasks) {
      if (taskId == task.getId()) {
        return task;
      }
    }
    return null;
  }
1255708
public List<Task> getTasksWithReference(Reference reference) {
		return getResourceFactory().getApiResource(
				"/task/" + reference.getType().name().toLowerCase() + "/"
						+ reference.getId() + "/").get(
				new GenericType<List<Task>>() {
				});
	}
1014109
private function _getCreateTaskContext(Task $task)
    {
        $result = new HttpCallContext();
        $result->setMethod(Resources::HTTP_POST);
        $result->setHeaders($this->_batchHeaders);
        $result->setUri($this->getUri());
        $result->setPath('/$1/Tasks');
        $result->setBody($this->wrapAtomEntry($task));
        $result->addStatusCode(Resources::STATUS_CREATED);

        return $result;
    }
655512
public static Package getTaskTemplatePackage(Long taskId) {
        try {
            for (Package pkg : getPackageList()) {
              if (pkg.containsTaskTemplate(taskId))
                  return pkg;
            }
            return Package.getDefaultPackage();
        }
        catch (CachingException ex) {
            logger.severeException(ex.getMessage(), ex);
            return null;
        }
    }
404981
public List<TaskLock> findLocksForTask(final Task task)
  {
    giant.lock();

    try {
      return Lists.transform(
          findLockPossesForTask(task), new Function<TaskLockPosse, TaskLock>()
          {
            @Override
            public TaskLock apply(TaskLockPosse taskLockPosse)
            {
              return taskLockPosse.getTaskLock();
            }
          }
      );
    }
    finally {
      giant.unlock();
    }
  }
447048
private Map<PackageUrl, ComponentReport> requestReports(final Dependency[] dependencies) throws Exception {
        log.debug("Requesting component-reports for {} dependencies", dependencies.length);

        // create requests for each dependency which has a PURL identifier
        List<PackageUrl> packages = new ArrayList<>();
        for (Dependency dependency : dependencies) {
            for (Identifier id : dependency.getSoftwareIdentifiers()) {
                if (id instanceof PurlIdentifier) {
                    PackageUrl purl = parsePackageUrl(id.getValue());
                    if (purl != null) {
                        packages.add(purl);
                    }
                }
            }
        }

        // only attempt if we have been able to collect some packages
        if (!packages.isEmpty()) {
            return client.requestComponentReports(packages);
        }

        log.warn("Unable to determine Package-URL identifiers for {} dependencies", dependencies.length);
        return Collections.emptyMap();
    }
963060
@Override
    public String getDestination(String task) {
        MappingConfig config = rdbMapping.get(task);
        if (config != null) {
            return config.getDestination();
        }
        return null;
    }
826423
public CollectionRequest<Task> subtasks(String task) {
    
        String path = String.format("/tasks/%s/subtasks", task);
        return new CollectionRequest<Task>(this, Task.class, path, "GET");
    }
760954
public java.util.List<String> getTasks() {
        if (tasks == null) {
            tasks = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return tasks;
    }
1068320
protected String addDependency(FunctionalTaskItem dependency) {
        Objects.requireNonNull(dependency);
        return this.taskGroup().addDependency(dependency);
    }
272468
public static Integer[] getArrayOfFlags(Map< String, Dependency> dependencies) {
        List<Integer> flagsList = new LinkedList<Integer>();

        for (Dependency dependency : dependencies.values()) {
            flagsList.add(dependency.getFlags());
        }

        return flagsList.toArray(new Integer[flagsList.size()]);
    }