Get the collection of all transient dependencies defined in this instance.

@return the collection of all transient dependencies defined in this instance.
171892
public Set<ArtifactSpec> getTransientDependencies() {
        if (null == allTransient) {
            allTransient = getTransientDependencies(true, true);
        }
        return allTransient;
    }
163949
public Set<SourceFile> getDependencies() {

		Set<SourceFile> sourceFiles = new TreeSet<SourceFile>();

		// Include all of the standard dependencies.
		for (Template t : dependencies.values()) {
			sourceFiles.add(t.sourceFile);
		}

		// Add the files that were looked-up but not found as well as the files
		// included via the file_contents() function.
		sourceFiles.addAll(otherDependencies);

		return Collections.unmodifiableSet(sourceFiles);
	}
639894
public List<TypedDependency> typedDependenciesCollapsed(boolean includeExtras) {
    List<TypedDependency> tdl = typedDependencies(includeExtras);
    collapseDependencies(tdl, false);
    return tdl;
  }
521044
public Collection<Message> getAll() {
        final int firstMessagePosition = this.getFirstPosition();
        if (firstMessagePosition < MessageStore.INITIAL_MESSAGE_POSITION) {
            return Collections.unmodifiableList(Collections.emptyList());
        }
        return this.getFrom(firstMessagePosition);
    }
1184071
private List<Dependency> getProvisionableDependencies()
    {
        List<Dependency> dependencies = new ArrayList<Dependency>();
        getLog().info( "Adding dependencies in scope " + dependencyScope );
        for( Dependency d : getDependencies() )
        {
            if( d.getScope() != null && d.getScope().equalsIgnoreCase( dependencyScope ) )
            {
                dependencies.add( d );
            }
        }

        return dependencies;
    }
383183
private List<CompilerInput> getDepthFirstDependenciesOf(
      CompilerInput rootInput,
      Set<CompilerInput> unreachedInputs,
      Map<String, CompilerInput> inputsByProvide) {
    List<CompilerInput> orderedInputs = new ArrayList<>();
    if (!unreachedInputs.remove(rootInput)) {
      return orderedInputs;
    }

    for (String importedNamespace : rootInput.getRequiredSymbols()) {
      CompilerInput dependency = null;
      if (inputsByProvide.containsKey(importedNamespace)
          && unreachedInputs.contains(inputsByProvide.get(importedNamespace))) {
        dependency = inputsByProvide.get(importedNamespace);
      }

      if (dependency != null) {
        orderedInputs.addAll(
            getDepthFirstDependenciesOf(dependency, unreachedInputs, inputsByProvide));
      }
    }

    orderedInputs.add(rootInput);
    return orderedInputs;
  }
1245625
public Map<String,Set<String>> getDependencies() {
        Map<String,Set<String>> new_deps = new HashMap<String,Set<String>>();
        if (explicitPackages == null) return new_deps;
        for (Name pkg : explicitPackages) {
            Set<Name> set = deps.get(pkg);
            if (set != null) {
                Set<String> new_set = new_deps.get(pkg.toString());
                if (new_set == null) {
                    new_set = new HashSet<String>();
                    // Modules beware....
                    new_deps.put(":"+pkg.toString(), new_set);
                }
                for (Name d : set) {
                    new_set.add(":"+d.toString());
                }
            }
        }
        return new_deps;
    }
1007247
def get_dependencies(self):
        """"""
        # pylint: disable=no-member
        return super().get_dependencies() + [
            Data.collection_set,
            Data.entity_set,
            Data.parents,
        ]
1030801
ImmutableCollection<Require> getKnownRequires() {
    return concat(
        dependencyInfo != null ? dependencyInfo.getRequires() : ImmutableList.of(), extraRequires);
  }
439277
@Override
  public Collection<FastFuture<T>> getAllResults() {
    results.addAll(active);
    active.clear();
    return results;
  }
932994
public function getDependencies()
    {
        if (empty($this->dependencies)) {
            foreach ($this->getManifest()->getDependencies() as $id => $version) {
                $this->dependencies[$id] = $version;
                $dependence = $this->getExtensionManager()->getExtensionById($id);
                $this->dependencies = array_merge($this->dependencies, $dependence->getDependencies());
            }
        }
        return $this->dependencies;
    }
1016184
public List<T> getAll() {
		List<T> result = new ArrayList<T>();
		if (nodes != null)
			for(Node element : nodes) 
				result.add(getCachedOrNewRepresentation(element));
		return result;
	}
	
	public int size() {
		return nodes.size();
	}
	
	public T get(int index) {
		return getCachedOrNewRepresentation(nodes.get(index));
	}
		
	public Iterator<T> iterator() {
		return getAll().iterator();
	}
}
42465
public List<T> getList() {
    final ArrayList<T> list = new ArrayList<T>();
    for (final Entry<T, AtomicInteger> e : this.map.entrySet()) {
      for (int i = 0; i < e.getValue().get(); i++) {
        list.add(e.getKey());
      }
    }
    return list;
  }
797727
def dependencies(self):
        
        result = []
        dependencies = javabridge.get_collection_wrapper(
            javabridge.call(self.jobject, "getDependencies", "()Ljava/util/List;"))
        for dependency in dependencies:
            result.append(Dependency(dependency))
        return result
1014857
ImmutableCollection<String> getKnownProvides() {
    return concat(
        dependencyInfo != null ? dependencyInfo.getProvides() : ImmutableList.<String>of(),
        extraProvides);
  }
646123
public List<T> resolve() {
        blockedBy = new HashMap<>();
        Set<T> queue = new LinkedHashSet<>();
        Set<T> allElements = new HashSet<>();
        queue.addAll(elements);
        while (!queue.isEmpty()) {
            T element = queue.iterator().next();
            Set<T> dependencies = dependencyProvider.getDependencies(element);
            queue.addAll(dependencies);
            blockedBy.put(element, dependencies);
            queue.remove(element);
            allElements.add(element);
        }
        List<T> result = new LinkedList<>();
        for (T element : allElements) {
            resolve(element, result);
        }
        return result;
    }
186616
public synchronized List<E> getAll() {
		ArrayList<E> list = new ArrayList<E>();

		for (E element : listElements) {
			if (element != null) {
				list.add(element);
			}
		}

		return list;
	}