This returns the ValueSet for the specified dependency from the DependencyToEntryTable.

@param dependency The dependency to get the entries for.
@return The ValueSet containing all entries for this dependency.
971448
public ValueSet getEntries(Object dependency) {
        ValueSet valueSet = (ValueSet) dependencyToEntryTable.get(dependency);

        return valueSet;
    }
754134
private String[] getDependencyCells(final Dependency dependency, final License license) {
        final List<String> cells = new ArrayList<>();

        if(decorator.getShowSources()){
            cells.add(dependency.getSourceName());
        }

        if(decorator.getShowSourcesVersion()){
            cells.add(dependency.getSourceVersion());
        }

        if(decorator.getShowTargets()){
            cells.add(dependency.getTarget().getGavc());
        }

        if(decorator.getShowTargetsDownloadUrl()){
            cells.add(dependency.getTarget().getDownloadUrl());
        }

        if(decorator.getShowTargetsSize()){
            cells.add(dependency.getTarget().getSize());
        }

        if(decorator.getShowScopes()){
            cells.add(dependency.getScope().name());
        }

        if(decorator.getShowLicenses()){
            cells.add(license.getName());
        }

        if(decorator.getShowLicensesLongName()){
            cells.add(license.getLongName());
        }

        if(decorator.getShowLicensesUrl()){
            cells.add(license.getUrl());
        }

        if(decorator.getShowLicensesComment()){
            cells.add(license.getComments());
        }

        return cells.toArray(new String[cells.size()]);
    }
390677
public static String generate(org.sonatype.aether.graph.Dependency dependency) {
        return dependency.getArtifact().toString();
    }
163421
DependencyInfo getDependencyInfo() {
    if (dependencyInfo == null) {
      dependencyInfo = generateDependencyInfo();
    }
    if (!extraRequires.isEmpty() || !extraProvides.isEmpty()) {
      dependencyInfo =
          SimpleDependencyInfo.builder(getName(), getName())
              .setProvides(concat(dependencyInfo.getProvides(), extraProvides))
              .setRequires(concat(dependencyInfo.getRequires(), extraRequires))
              .setTypeRequires(dependencyInfo.getTypeRequires())
              .setLoadFlags(dependencyInfo.getLoadFlags())
              .setHasExternsAnnotation(dependencyInfo.getHasExternsAnnotation())
              .setHasNoCompileAnnotation(dependencyInfo.getHasNoCompileAnnotation())
              .build();
      extraRequires.clear();
      extraProvides.clear();
    }
    return dependencyInfo;
  }
433585
private void getAllDependents(Set<PathEntry> result, String name) {
        Set<String> depNames = dependenctRelativePaths.get(name);
        if (depNames == null) {
            return;
        }
        for (String dep : depNames) {
            PathEntry entry = pathEntries.get(dep);
            if (entry != null) {
                result.add(entry);
                getAllDependents(result, dep);
            }
        }
    }
396571
public Map<String, Attribute> getDependencies()
        throws CacheReloadException
    {
        if (this.dependencies == null) {
            this.dependencies = new TreeMap<>();
            // in case of a rate attribute the dependencies to the currencies
            // must be given
            if (getProperties().containsKey("CurrencyAttribute4Rate")) {
                this.dependencies.put("CurrencyAttribute4Rate",
                                getParent().getAttribute(getProperties().get("CurrencyAttribute4Rate")));
                this.dependencies.put("TargetCurrencyAttribute4Rate",
                                getParent().getAttribute(getProperties().get("TargetCurrencyAttribute4Rate")));
            }
        }
        return this.dependencies;
    }
835755
public Set<JSModule> getAllDependencies() {
    // JSModule uses identity semantics
    Set<JSModule> allDeps = Sets.newIdentityHashSet();
    allDeps.addAll(deps);
    ArrayDeque<JSModule> stack = new ArrayDeque<>(deps);

    while (!stack.isEmpty()) {
      JSModule module = stack.pop();
      List<JSModule> moduleDeps = module.deps;
      for (JSModule dep : moduleDeps) {
        if (allDeps.add(dep)) {
          stack.push(dep);
        }
      }
    }
    return allDeps;
  }
90376
public void add(Object dependency, ValueSet valueSet) {
		if (dependency == null) {
			throw new IllegalArgumentException("dependency cannot be null");
		}
		if (valueSet != null) {
			dependencyToEntryTable.put(dependency, valueSet);
		}
	}
127581
public Multimap<Integer, DependencyStructure> getAllDependenciesIndexedByHeadWordIndex() {
    Multimap<Integer, DependencyStructure> map = HashMultimap.create();
    for (DependencyStructure dep : getAllDependencies()) {
      map.put(dep.getHeadWordIndex(), dep);
    }
    return map;
  }
215341
public List<String> getDependenciesNotation(List<String> scopes) {
        List<String> notations = new ArrayList<String>();

        for (Dependency dependency : getDependencies(scopes)) {
            notations.add(Notation.generate(dependency));
        }

        return notations;
    }
251896
@Override
    @SuppressWarnings("ReferenceEquality")
    protected boolean evaluateDependencies(final Dependency dependency, final Dependency nextDependency, final Set<Dependency> dependenciesToRemove) {
        Dependency main;
        //CSOFF: InnerAssignment
        if ((main = getMainGemspecDependency(dependency, nextDependency)) != null) {
            if (main == dependency) {
                mergeDependencies(dependency, nextDependency, dependenciesToRemove);
            } else {
                mergeDependencies(nextDependency, dependency, dependenciesToRemove);
                return true; //since we merged into the next dependency - skip forward to the next in mainIterator
            }
        } else if ((main = getMainSwiftDependency(dependency, nextDependency)) != null) {
            if (main == dependency) {
                mergeDependencies(dependency, nextDependency, dependenciesToRemove);
            } else {
                mergeDependencies(nextDependency, dependency, dependenciesToRemove);
                return true; //since we merged into the next dependency - skip forward to the next in mainIterator
            }
        } else if ((main = getMainAndroidDependency(dependency, nextDependency)) != null) {
            if (main == dependency) {
                mergeDependencies(dependency, nextDependency, dependenciesToRemove);
            } else {
                mergeDependencies(nextDependency, dependency, dependenciesToRemove);
                return true; //since we merged into the next dependency - skip forward to the next in mainIterator
            }
        } else if ((main = getMainDotnetDependency(dependency, nextDependency)) != null) {
            if (main == dependency) {
                mergeDependencies(dependency, nextDependency, dependenciesToRemove);
            } else {
                mergeDependencies(nextDependency, dependency, dependenciesToRemove);
                return true; //since we merged into the next dependency - skip forward to the next in mainIterator
            }
        }
        //CSON: InnerAssignment
        return false;
    }
888147
public DependencyList getDependencyList(int id) {
        ClientResource resource = new ClientResource(Route.DEPENDENCY.url(id));

        try {
            Representation repr = resource.get();
            return mapper.readValue(repr.getText(), DependencyList.class);
        } catch (IOException ex) {
            LEX4JLogger.log(Level.WARNING, "Could not retrieve lot dependencies correctly!");
            return null;
        }
    }
646076
public Set<Deque<Archive>> inverseDependences() throws IOException {
        // create a new dependency finder to do the analysis
        DependencyFinder dependencyFinder = new DependencyFinder(configuration, DEFAULT_FILTER);
        try {
            // parse all archives in unnamed module to get compile-time dependences
            Stream<Archive> archives =
                Stream.concat(configuration.initialArchives().stream(),
                              configuration.classPathArchives().stream());
            if (apiOnly) {
                dependencyFinder.parseExportedAPIs(archives);
            } else {
                dependencyFinder.parse(archives);
            }

            Graph.Builder<Archive> builder = new Graph.Builder<>();
            // include all target nodes
            targets().forEach(builder::addNode);

            // transpose the module graph
            configuration.getModules().values().stream()
                .forEach(m -> {
                    builder.addNode(m);
                    m.descriptor().requires().stream()
                        .map(Requires::name)
                        .map(configuration::findModule)  // must be present
                        .forEach(v -> builder.addEdge(v.get(), m));
                });

            // add the dependences from the analysis
            Map<Archive, Set<Archive>> dependences = dependencyFinder.dependences();
            dependences.entrySet().stream()
                .forEach(e -> {
                    Archive u = e.getKey();
                    builder.addNode(u);
                    e.getValue().forEach(v -> builder.addEdge(v, u));
                });

            // transposed dependence graph.
            Graph<Archive> graph = builder.build();
            trace("targets: %s%n", targets());

            // Traverse from the targets and find all paths
            // rebuild a graph with all nodes that depends on targets
            // targets directly and indirectly
            return targets().stream()
                .map(t -> findPaths(graph, t))
                .flatMap(Set::stream)
                .collect(Collectors.toSet());
        } finally {
            dependencyFinder.shutdown();
        }
    }
277569
public Set<String> getDependenciesNotation() {
        Set<String> notations = new HashSet<String>();
        
        for (Dependency dependency : currentDependencies() ) {
            notations.add(Notation.generate(dependency));
        }

        return notations;
    }
662563
public double getDependencyStructureLogProbability(DependencyStructure dependency,
      List<String> posTags) {
    int headIndex = dependency.getHeadWordIndex();
    int objectIndex = dependency.getObjectWordIndex();
    Assignment assignment = Assignment.unionAll(
        dependencyHeadVar.outcomeArrayToAssignment(dependency.getHead()),
        dependencySyntaxVar.outcomeArrayToAssignment(dependency.getHeadSyntacticCategory()),
        dependencyArgNumVar.outcomeArrayToAssignment(dependency.getArgIndex()),
        dependencyArgVar.outcomeArrayToAssignment(dependency.getObject()),
        dependencyHeadPosVar.outcomeArrayToAssignment(posTags.get(headIndex)),
        dependencyArgPosVar.outcomeArrayToAssignment(posTags.get(objectIndex)));

    if (!dependencyDistribution.getVars().isValidAssignment(assignment)) {
      return Double.NEGATIVE_INFINITY;
    } else {
      return dependencyDistribution.getUnnormalizedLogProbability(assignment);
    }
  }
993230
private Set<Artifact> getProjectDependencyManagement() {
        Set<Artifact> result = new LinkedHashSet<Artifact>();
        DependencyManagement dependencyManagement = getProject().getDependencyManagement();
        if (dependencyManagement != null) {
            for (Dependency dependency : dependencyManagement.getDependencies()) {
                result.add(toArtifact(dependency));
            }
        }
        return result;
    }
448219
@Override
    public Set<Entry<String, V>> entrySet() {
        HashMap<String, V> entries = new HashMap<>();
        entriesR(root.getLeft(), -1, entries);
        return entries.entrySet();
    }