Returns the DependencyInfo object, generating it lazily if necessary.
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;
  }
200170
def _get_dependencies(self):
        
        #The only complication with the whole process is that we need to get the list of
        #dependencies for the current module. For full lib, we compile *all* the files in
        #the directory, otherwise only those that are explicitly required.
        from os import path
        modules = self.module.search_dependencies()
        result = {}
        for module in modules:
            self.module.parent.load_dependency(module, True, True, False)
            
        for modname, module in list(self.module.parent.modules.items()):
            pathkey = path.dirname(module.filepath).lower()
            if pathkey not in result:
                result[pathkey] = path.dirname(module.filepath)

        return result
832425
private int getDependencies(JSONObject npmLsJson, List<String> linesOfNpmLs, int currentLineNumber, Collection<DependencyInfo> dependencies) {
        if (npmLsJson.has(Constants.DEPENDENCIES)) {
            JSONObject dependenciesJsonObject = npmLsJson.getJSONObject(Constants.DEPENDENCIES);
            if (dependenciesJsonObject != null) {
                for (int i = 0; i < dependenciesJsonObject.keySet().size(); i++) {
                    String currentLine = linesOfNpmLs.get(currentLineNumber);
                    // Examples:
                    // +-- UNMET DEPENDENCY @material-ui/core@1.5.0
                    // | +-- UNMET DEPENDENCY @babel/runtime@7.0.0-beta.42
                    // | | `-- UNMET DEPENDENCY regenerator-runtime@0.11.1
                    // |   | +-- UNMET OPTIONAL DEPENDENCY are-we-there-yet@1.1.4
                    // |   | | +-- UNMET OPTIONAL DEPENDENCY delegates@1.0.0
                    // |   | | `-- UNMET OPTIONAL DEPENDENCY readable-stream@2.3.6
                    if (currentLine.endsWith(DEDUPED) || currentLine.contains(UNMET_DEPENDENCY)) {
                        currentLineNumber++;
                        continue;
                    }
                    String dependencyAlias = getTheNextPackageNameFromNpmLs(currentLine);
                    try {
                        JSONObject dependencyJsonObject = dependenciesJsonObject.getJSONObject(dependencyAlias);
                        DependencyInfo dependency = getDependency(dependencyAlias, dependencyJsonObject);
                        if (dependency != null) {
                            dependencies.add(dependency);
                            logger.debug("Collect child dependencies of {}", dependencyAlias);
                            // collect child dependencies
                            Collection<DependencyInfo> childDependencies = new ArrayList<>();
                            currentLineNumber = getDependencies(dependencyJsonObject, linesOfNpmLs, currentLineNumber + 1, childDependencies);
                            dependency.getChildren().addAll(childDependencies);
                        } else {
                            // it can be only if was an error in 'npm ls'
                            if (dependencyJsonObject.has(REQUIRED)) {
                                Object requiredObject = dependencyJsonObject.get(REQUIRED);
                                if (requiredObject instanceof JSONObject) {
                                    currentLineNumber = getDependencies((JSONObject) requiredObject, linesOfNpmLs, currentLineNumber + 1, new ArrayList<>());
                                } else {
                                    currentLineNumber++;
                                }
                            } else {
                                currentLineNumber++;
                            }
                        }
                    } catch (JSONException e){
                        if (ignoreNpmLsErrors) {
                            logger.error(e.getMessage());
                            logger.debug("{}", e.getStackTrace());
                            currentLineNumber++;
                        } else {
                            throw e;
                        }
                    }
                }
            }
        }
        return currentLineNumber;
    }
783113
@Override
	public Iterable<String> getDependencyNames() throws ProcessingDependenciesException {
		Iterable<String> result = null;
		try {
			getReadLock();
			try {
				result = depMap.keySet();
			} finally {
				releaseReadLock();
			}
		} catch (InterruptedException e) {
			if (log.isLoggable(Level.SEVERE)) {
				log.log(Level.SEVERE, e.getMessage(), e);
			}
		}
		return result;
	}
923576
function getDepInfo (dep, currFile, customDepResolve) {
  let depResolve

  if (!customDepResolve) {
    depResolve = defaultDepResolve
  } else {
    depResolve = (dep, currFile) => {
      // parse defaultResolve as third param
      return customDepResolve(dep, currFile, defaultDepResolve)
    }
  }

  let currType = getParseType(currFile)
  let type = getParseType(dep) || currType
  let info = {
    parent: currFile,     // parent file path
    type: type,           // current file type (js/css)
    raw: dep,             // raw dependency name (require('./xxx') => './xxx')
    name: null,           // formated dependency name ('~@alife/xxx' => '@alife/xxx')
    module: null,         // module name (only external module)
    file: null            // resolved file name (only relative file)
  }

  info.name = depResolve(dep, currFile)

  if (!info.name.startsWith('.')) {
    if (info.name.startsWith('@')) {
      info.module = info.name.split('/', 2).join('/')
    } else {
      info.module = info.name.split('/', 1)[0]
    }
  } else {
    info.file = fileResolve(info.name, currFile)

    if (!info.file) {
      throw new ResolveError(info.name, currFile)
    }
  }

  return info
}
86578
private static List<DependencyInfo> getDependencies(JsonReader reader) throws IOException {
        Gson gson = new Gson();
        List<DependencyInfo> dependencies = new ArrayList<>();
        reader.beginArray();
        while (reader.hasNext()) {
            DependencyInfo dependencyInfo = gson.fromJson(reader, DependencyInfo.class);
            dependencies.add(dependencyInfo);
        }
        reader.endArray();
        return dependencies;
    }
390677
public static String generate(org.sonatype.aether.graph.Dependency dependency) {
        return dependency.getArtifact().toString();
    }
26584
def dependents(self, on_predicate=None, from_predicate=None):
    
    core = set(self.targets(on_predicate))
    dependees = defaultdict(set)
    for target in self.targets(from_predicate):
      for dependency in target.dependencies:
        if dependency in core:
          dependees[target].add(dependency)
    return dependees
128236
def get_dependency_extractor(self):
        
        if self.dependency_layer is not None:    #otherwise there are no dependencies
            if self.my_dependency_extractor is None:
                self.my_dependency_extractor = Cdependency_extractor(self)
            return self.my_dependency_extractor
        else:
            return None
241467
public static List<DependencyInfo> readDependencies(InputStream in) throws IOException {
        try (InputStreamReader inputStreamReader = new InputStreamReader(in, UTF_8);
             BufferedReader br = new BufferedReader(inputStreamReader);
             JsonReader reader = new JsonReader(br)) {
            return getDependencies(reader);
        } catch (IOException ex) {
            logger.error("Failed to read dependencies: {}", ex.getMessage());
        }
        return null;
    }
810697
function getDependency(dependency) {
            if (dependency) {
                return angular.isString(dependency) ? $injector.get(dependency) : dependency;
            }

            return undefined;
        }
168652
def get_dependencies(self, item):
        
        def _get_sub_dependency(sub_item):
            e = self._deps.get(sub_item)
            if e is None:
                return self.get_default()

            if e.dependencies is NotInitialized:
                e.dependencies = self.merge_dependency(sub_item, _get_sub_dependency, e.parent)
            return e.dependencies

        return _get_sub_dependency(item)
253631
def get_dependency_type(_type):
        
        if _type == DependencyTypes.AFTER:
            return 'after'
        elif _type == DependencyTypes.AFTER_ANY:
            return 'afterany'
        elif _type == DependencyTypes.AFTER_CORR:
            return 'aftercorr'
        elif _type == DependencyTypes.AFTER_NOT_OK:
            return 'afternotok'
        elif _type == DependencyTypes.AFTER_OK:
            return 'afterok'
        else:
            return None
950545
def get_dependency_graph(component):
    
    if component not in DEPENDENCIES:
        raise Exception("%s is not a registered component." % get_name(component))

    if not DEPENDENCIES[component]:
        return {component: set()}

    graph = defaultdict(set)

    def visitor(c, parent):
        if parent is not None:
            graph[parent].add(c)

    walk_dependencies(component, visitor)

    graph = dict(graph)

    # Find all items that don't depend on anything.
    extra_items_in_deps = _reduce(set.union, graph.values(), set()) - set(graph.keys())

    # Add empty dependencies where needed.
    graph.update(dict((item, set()) for item in extra_items_in_deps))

    return graph
305352
public static ObjectInfo getObjectInfo(Class c)
	{
		ObjectInfo info = cachedClassInfoMap.get(c);
		if (info == null)
		{
			synchronized (c)
			{

				info = new ObjectInfo(c);
				cachedClassInfoMap.put(c, info);
			}
		}
		return info;
	}
320549
def get_dependencies(primary_type, types):
    
    deps = set()
    struct_names_yet_to_be_expanded = [primary_type]

    while len(struct_names_yet_to_be_expanded) > 0:
        struct_name = struct_names_yet_to_be_expanded.pop()

        deps.add(struct_name)
        fields = types[struct_name]
        for field in fields:
            if field["type"] not in types:
                # We don't need to expand types that are not user defined (customized)
                continue
            elif field["type"] in deps:
                # skip types that we have already encountered
                continue
            else:
                # Custom Struct Type
                struct_names_yet_to_be_expanded.append(field["type"])

    # Don't need to make a struct as dependency of itself
    deps.remove(primary_type)

    return tuple(deps)
1164332
private <T> List<Object> getDependencies(T extension) {
    return new ArrayList<>(evaluateAnnotatedClasses(extension, DependsUpon.class));
  }