Add a "post-run" dependent task item for this task item.

@param dependent the "post-run" dependent task item.
@return key to be used as parameter to taskResult(string) method to retrieve result of root
task in the given dependent task group
11417
public String addPostRunDependent(FunctionalTaskItem dependent) {
        Objects.requireNonNull(dependent);
        return this.taskGroup().addPostRunDependent(dependent);
    }
582197
@SuppressWarnings("unchecked")
    protected String addPostRunDependent(Creatable<? extends Indexable> creatable) {
        TaskGroup.HasTaskGroup dependency = (TaskGroup.HasTaskGroup) creatable;
        return this.addPostRunDependent(dependency);
    }
473418
public int addTask(Task task, Object remoteTask)
    {
        if (m_taskMain == null)
        {
            if (task != null)
                if (task.isMainTaskCandidate())
                    m_taskMain = task;
        }
        m_mapTasks.put(task, (RemoteTask)remoteTask);
        return m_mapTasks.size();
    }
336575
public ServiceGraphModule removeDependency(Key<?> key, Key<?> keyDependency) {
		removedDependencies.computeIfAbsent(key, key1 -> new HashSet<>()).add(keyDependency);
		return this;
	}
144231
public ServiceGraphModule addDependency(Key<?> key, Key<?> keyDependency) {
		addedDependencies.computeIfAbsent(key, key1 -> new HashSet<>()).add(keyDependency);
		return this;
	}
355671
static Observable<Parameter> parametersAfterDependencies(Query query) {
        return concatButIgnoreFirstSequence(query.depends(), query.parameters());
    }
551919
public ItemRequest<Task> addDependencies(String task) {
    
        String path = String.format("/tasks/%s/addDependencies", task);
        return new ItemRequest<Task>(this, Task.class, path, "POST");
    }
516489
public void add(Object dependency, Object entry) {  //SKS-O
		if (tc.isDebugEnabled())
			Tr.debug(tc, "IMPORTANT: adding dependency " + dependency + " --> " + entry);
		if (dependency == null) {
			throw new IllegalArgumentException("dependency cannot be null");
		}
		ValueSet valueSet = (ValueSet) dependencyToEntryTable.get(dependency);

		if (valueSet == null) {
			valueSet = new ValueSet(4);
			dependencyToEntryTable.put(dependency, valueSet);
		}
		valueSet.add(entry);
	}
251170
public DependencyContainer add(Dependency dependency)
  {
    if (dependency == this)
      throw new IllegalArgumentException("Can't add self as a dependency.");
    
    if (! _dependencyList.contains(dependency))
      _dependencyList.add(dependency);

    // server/1d0w
    // XXX: _lastCheckTime = 0;

    return this;
  }
701455
public void setDependsOn(java.util.Collection<JobDependency> dependsOn) {
        if (dependsOn == null) {
            this.dependsOn = null;
            return;
        }

        this.dependsOn = new java.util.ArrayList<JobDependency>(dependsOn);
    }
1372040
public synchronized boolean addDependingJob(Job dependingJob) {
    if (this.state == Job.WAITING) { //only allowed to add jobs when waiting
      if (this.dependingJobs == null) {
        this.dependingJobs = new ArrayList<Job>();
      }
      return this.dependingJobs.add(dependingJob);
    } else {
      return false;
    }
  }
1068320
protected String addDependency(FunctionalTaskItem dependency) {
        Objects.requireNonNull(dependency);
        return this.taskGroup().addDependency(dependency);
    }
77888
def _add_dependency(self, key, dependlist, i, isSubroutine, anexec):
        """"""
        #First determine if the reference is to a derived type variable
        lkey = key.lower()
        if "%" in key:
            #Find the type of the base variable and then perform a tree
            #search at the module level to determine if the final reference
            #is a valid executable
            base = key.split("%")[0]
            ftype = None
            if base in anexec.members and anexec.members[base].is_custom:
                ftype = anexec.members[base].kind
            elif base in anexec.parameters and anexec.parameters[base].is_custom:
                ftype = anexec.parameters[base].kind

            if ftype is not None:
                end = anexec.module.type_search(ftype, key)
                if end is not None and isinstance(end, TypeExecutable):
                    #We have to overwrite the key to include the actual name of the type
                    #that is being referenced instead of the local name of its variable.
                    tname = "{}%{}".format(ftype, '%'.join(key.split('%')[1:]))
                    d = Dependency(tname, dependlist[i + 1], isSubroutine, anexec)
                    anexec.add_dependency(d)
                    
        elif lkey not in ["for", "forall", "do"]:
            #This is a straight forward function/subroutine call, make sure that
            #the symbol is not a local variable or parameter, then add it
            if not lkey in anexec.members and not lkey in anexec.parameters \
               and not lkey in self._intrinsic:                
                #One issue with the logic until now is that some one-line statements
                #like "if (cond) call subroutine" don't trigger the subroutine flag
                #of the dependency.
                if dependlist[i-1] == "call":
                    isSubroutine = True
                d = Dependency(dependlist[i], dependlist[i + 1], isSubroutine, anexec)
                anexec.add_dependency(d)
725818
def add_dependent_assembly(self, manifestVersion=None, noInheritable=False, 
                 noInherit=False, type_=None, name=None, language=None, 
                 processorArchitecture=None, version=None, 
                 publicKeyToken=None, description=None, 
                 requestedExecutionLevel=None, uiAccess=None, 
                 dependentAssemblies=None, files=None, 
                 comInterfaceExternalProxyStubs=None):
        
        self.dependentAssemblies.append(Manifest(manifestVersion, 
                                        noInheritable, noInherit, type_, name, 
                                        language, processorArchitecture, 
                                        version, publicKeyToken, description, 
                                        requestedExecutionLevel, uiAccess, 
                                        dependentAssemblies, files, 
                                        comInterfaceExternalProxyStubs))
        if self.filename:
            # Enable search for private assembly by assigning bogus filename
            # (only the directory has to be correct)
            self.dependentAssemblies[-1].filename = ":".join((self.filename, 
                                                              name))
1353467
private void initializeDependentKeys() {
        visit(new Visitor<NodeT>() {
            @Override
            public void visitNode(NodeT node) {
                if (node.dependencyKeys().isEmpty()) {
                    return;
                }

                String dependentKey = node.key();
                for (String dependencyKey : node.dependencyKeys()) {
                    nodeTable.get(dependencyKey)
                            .addDependent(dependentKey);
                }
            }

            @Override
            public  void visitEdge(String fromKey, String toKey, EdgeType edgeType) {
                if (edgeType == EdgeType.BACK) {
                    throw new IllegalStateException("Detected circular dependency: " + findPath(fromKey, toKey));
                }
            }
        });
    }
682449
public static void addServerExecutorDependency(ServiceBuilder<?> serviceBuilder, InjectedValue<ExecutorService> injector, boolean optional) {
    ServiceBuilder.DependencyType type = optional ? ServiceBuilder.DependencyType.OPTIONAL : ServiceBuilder.DependencyType.REQUIRED;
    serviceBuilder.addDependency(type, JBOSS_SERVER_EXECUTOR, ExecutorService.class, injector);
  }
1159830
public int add(Object dependency, ValueSet valueSet, Object entry) {
        int returnCode = HTODDynacache.NO_EXCEPTION;
        dependencyNotUpdatedTable.remove(dependency);
        valueSet.add(entry);
        if (valueSet.size() > this.delayOffloadEntriesLimit) {
            if (this.type == DEP_ID_TABLE) {
                returnCode = this.htod.writeValueSet(HTODDynacache.DEP_ID_DATA, dependency, valueSet, HTODDynacache.ALL);  // valueSet may be empty after writeValueSet
                this.htod.cache.getCacheStatisticsListener().depIdsOffloadedToDisk(dependency);
                if (tc.isDebugEnabled())
                	Tr.debug(tc, "***** add dependency id=" + dependency + " size=" + valueSet.size());
            } else {
                returnCode = this.htod.writeValueSet(HTODDynacache.TEMPLATE_ID_DATA, dependency, valueSet, HTODDynacache.ALL);  // valueSet may be empty after writeValueSet
                this.htod.cache.getCacheStatisticsListener().templatesOffloadedToDisk(dependency);
                if (tc.isDebugEnabled())
                	Tr.debug(tc, "***** add dependency id=" + dependency + " size=" + valueSet.size());
            }
            dependencyToEntryTable.remove(dependency);
            if (returnCode == HTODDynacache.DISK_SIZE_OVER_LIMIT_EXCEPTION && valueSet.size() > 0) {
                this.htod.delCacheEntry(valueSet, CachePerf.DISK_OVERFLOW, CachePerf.LOCAL, 
                                        !Cache.FROM_DEPID_TEMPLATE_INVALIDATION, 
                                        HTODInvalidationBuffer.FIRE_EVENT);
                returnCode = HTODDynacache.NO_EXCEPTION;
            }
        }
        return returnCode;
    }