Returns the typed dependencies of this grammatical structure.
<p/>
If the boolean argument is true, the list of typed dependencies
returned may include "extras", and does not follow a tree structure.
974978
public List<TypedDependency> typedDependencies(boolean includeExtras) {
    List<TypedDependency> deps = includeExtras ? allTypedDependencies
                                                       : typedDependencies;
    correctDependencies(deps);
    return deps;
  }
805672
private boolean isDependent(String style) {
		if (!style.trim().startsWith("<")) {
			return false;
		}
		Pattern p = Pattern.compile("rel\\s*=\\s*\"\\s*independent-parent\\s*\"");
		Matcher m = p.matcher(style);
		return m.find();
	}
804001
private List<AgigaTypedDependency> parseDependencies(VTDNav vn, DependencyForm form) throws NavException,
            PilotException {
        require (vn.matchElement(AgigaConstants.SENTENCE));

        // Move to the <basic-deps> tag
        require (vn.toElement(VTDNav.FC, form.getXmlTag()));

        List<AgigaTypedDependency> agigaDeps = new ArrayList<AgigaTypedDependency>();
        
        // Loop through the dep tags
        AutoPilot basicDepRelAp = new AutoPilot(vn);
        basicDepRelAp.selectElement(AgigaConstants.DEP);
        while (basicDepRelAp.iterate()) {
            // Read the type, governor, and dependent
            String type = vn.toString(vn.getAttrVal(AgigaConstants.DEP_TYPE));
            require (vn.toElement(VTDNav.FC, AgigaConstants.GOVERNOR));
            int governorId = vn.parseInt(vn.getText());
            require (vn.toElement(VTDNav.NS, AgigaConstants.DEPENDENT));
            int dependentId = vn.parseInt(vn.getText());

            log.finer(String.format("\tdep type=%s\t%d-->%d", type, governorId, dependentId));

            // Subtract one, since the tokens are one-indexed in the XML but
            // zero-indexed in this API
            AgigaTypedDependency agigaDep = new AgigaTypedDependency(type, governorId - 1, dependentId - 1);
            agigaDeps.add(agigaDep);
        }
        return agigaDeps;
    }
672417
@Override
    public List<String> getDependencies() {
        List<String> dependencies = new ArrayList<String>();
        if (container.getSingle("dependencies") != null) {
            for (Node dep : container.getSingle("dependencies").get("dependency")) {
                dependencies.add(dep.getText());
            }
        }
        return dependencies;
    }
879751
public java.util.List<AdditionalAttribute> getAdditionalAttributes() {
        if (additionalAttributes == null) {
            additionalAttributes = new com.amazonaws.internal.SdkInternalList<AdditionalAttribute>();
        }
        return additionalAttributes;
    }
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
825081
public List<TypedDependency> getStanfordTypedDependencies(DependencyForm form) {
        List<TypedDependency> dependencies = new ArrayList<TypedDependency>();
        if (this.nodes == null)
        	nodes = getStanfordTreeGraphNodes(form);

        List<AgigaTypedDependency> agigaDeps = getAgigaDeps(form);
        for (AgigaTypedDependency agigaDep : agigaDeps) {
            // Add one, since the tokens are zero-indexed but the TreeGraphNodes are one-indexed
            TreeGraphNode gov = nodes.get(agigaDep.getGovIdx() + 1);
            TreeGraphNode dep = nodes.get(agigaDep.getDepIdx() + 1);
            // Create the typed dependency
            TypedDependency typedDep = new TypedDependency(GrammaticalRelation.valueOf(agigaDep.getType()), gov, dep);
            dependencies.add(typedDep);
        }
        return dependencies;
    }
357998
private GrammaticalStructure tagDependencies(List<? extends HasWord> taggedWords) {
        GrammaticalStructure gs = nndepParser.predict(taggedWords);
        return gs;
    }
432762
public List<Class<?>> getTypes(boolean noAbstractTypes) {
		List<Class<?>> typeList = new ArrayList<Class<?>>();
		this.addType(typeList, noAbstractTypes);
		return typeList;
	}
1336353
public List<LibraryDescriptor.Dependency> getAllDependenciesAnyScope() {
		ArrayList<LibraryDescriptor.Dependency> list = new ArrayList<>(dependencies.size());
		list.addAll(dependencies);
		return list;
	}
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;
    }
62060
public List<DependencyStructure> getDependenciesWithHeadWord(int wordIndex) {
    List<DependencyStructure> deps = getAllDependencies();
    List<DependencyStructure> filteredDeps = Lists.newArrayList();
    for (DependencyStructure dep : deps) {
      if (dep.getHeadWordIndex() == wordIndex) {
        filteredDeps.add(dep);
      }
    }
    return filteredDeps;
  }
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;
    }
492145
def basic_dependencies(self):
        
        if self._basic_dependencies is None:
            deps = self._element.xpath('dependencies[@type="basic-dependencies"]')
            if len(deps) > 0:
                self._basic_dependencies = DependencyGraph(deps[0])
        return self._basic_dependencies
530785
public List<String> getIdsAddOnDependencies() {
		if (dependencies == null) {
			return Collections.emptyList();
		}

		List<String> ids = new ArrayList<>(dependencies.getAddOns().size());
		for (AddOnDep dep : dependencies.getAddOns()) {
			ids.add(dep.getId());
		}
		return ids;
	}
782452
protected List<Grammar> getEffectivelyUsedGrammars(final Grammar grammar) {
    final Function1<AbstractRule, Grammar> _function = (AbstractRule it) -> {
      return GrammarUtil.getGrammar(it);
    };
    final Function1<Grammar, Boolean> _function_1 = (Grammar it) -> {
      return Boolean.valueOf((it != grammar));
    };
    return IterableExtensions.<Grammar>toList(IterableExtensions.<Grammar>toSet(IterableExtensions.<Grammar>filter(ListExtensions.<AbstractRule, Grammar>map(GrammarUtil.allRules(grammar), _function), _function_1)));
  }
118267
def dependencies(self) -> List[Dependency]:
        """"""
        dependencies_str = DB.get_hash_value(self.key, 'dependencies')
        dependencies = []
        for dependency in ast.literal_eval(dependencies_str):
            dependencies.append(Dependency(dependency))
        return dependencies