private List<AndroidDependency> computeFlatLibraryList() { List<AndroidDependency> flatAndroidLibraries = Lists.newArrayList(); final List<DependencyNode> androidNodes = atomNode.getDependencies().stream() .filter(node -> node.getNodeType() == DependencyNode.NodeType.ANDROID) .collect(Collectors.toList()); computeFlatLibraryList(androidNodes, flatAndroidLibraries); return flatAndroidLibraries; }
private void computeFlatLibraryList( List<DependencyNode> androidDependencies, List<AndroidDependency> outFlatAndroidDependencies) { for (DependencyNode node : androidDependencies) { AndroidDependency androidDependency = (AndroidDependency) dependencyMap .get(node.getAddress()); if (outFlatAndroidDependencies.contains(androidDependency)) { continue; } final List<DependencyNode> androidNodes = node.getDependencies().stream() .filter(n -> n.getNodeType() == DependencyNode.NodeType.ANDROID) .collect(Collectors.toList()); computeFlatLibraryList(androidNodes, outFlatAndroidDependencies); outFlatAndroidDependencies.add(androidDependency); } } }
private void collectAtomLeaves(@NonNull Collection<DependencyNode> nodes, @NonNull List<AtomDependency> outLeaves) { for (DependencyNode node : nodes) { // collect the atom-only dependencies List<DependencyNode> atomList = node.getDependencies().stream() .filter(n -> n.getNodeType() == NodeType.ATOM) .collect(Collectors.toList()); if (atomList.isEmpty()) { outLeaves.add((AtomDependency) dependencyMap.get(node.getAddress())); } else { collectAtomLeaves(atomList, outLeaves); } } }
/** * Call back for the cache to create the graph item. Do not call directly. * @param dependencyNode the dependency node to be converted into the GraphItem * @return the GraphItem */ @NonNull private static GraphItemImpl createCachedGraphItem(@NonNull DependencyNode dependencyNode) { // clone the dependencies List<DependencyNode> children = dependencyNode.getDependencies(); List<GraphItem> clonedChildren = Lists.newArrayListWithCapacity(children.size()); for (DependencyNode child : children) { clonedChildren.add(sGraphItemCache.get(child)); } return new GraphItemImpl(dependencyNode.getAddress().toString(), clonedChildren); }
node.getDependencies(), outFlatDependencies, filter,
@NonNull private static AndroidLibraryImpl createSerializableAndroidLibrary( @NonNull DependencyItem<AndroidDependency> dependencyItem) { AndroidDependency androidDependency = dependencyItem.dependency; DependencyNode dependencyNode = dependencyItem.getOther(); List<DependencyNode> deps = dependencyNode.getDependencies(); List<AndroidLibrary> clonedDeps = Lists.newArrayListWithCapacity(deps.size()); for (DependencyNode childNode : deps) { if (childNode.getNodeType() != NodeType.ANDROID) { continue; } AndroidDependency childDependency = (AndroidDependency) dependencyItem.getMap().get(childNode.getAddress()); DependencyItem<AndroidDependency> childDepItem = dependencyItem .create(childDependency, childNode); AndroidLibrary clonedLib = sLibCache.get(childDepItem); if (clonedLib != null) { clonedDeps.add(clonedLib); } } // compute local jar even if the bundle isn't exploded. Collection<File> localJarOverride = findLocalJar(androidDependency); return new AndroidLibraryImpl( androidDependency, dependencyItem.isProvided(), dependencyItem.isSkipped(), clonedDeps, ImmutableList.of(), localJarOverride); }
private static void recursiveProvided( @NonNull MutableDependencyDataMap mutableDependencyDataMap, @NonNull List<DependencyNode> nodes, @NonNull Map<Object, Dependency> dependencyMap, boolean skipAndroidDependency, boolean skipJavaDependency) { for (DependencyNode node : nodes) { Dependency dep = dependencyMap.get(node.getAddress()); if (skipAndroidDependency) { if (dep instanceof AndroidDependency) { mutableDependencyDataMap.setProvided(dep); } } if (skipJavaDependency) { if (dep instanceof JavaDependency) { mutableDependencyDataMap.setProvided(dep); } } recursiveProvided( mutableDependencyDataMap, node.getDependencies(), dependencyMap, skipAndroidDependency, skipJavaDependency); } }
private void cloneJavaLibraries( @NonNull List<DependencyNode> nodes, @NonNull Set<JavaLibrary> outLibraries) { for (DependencyNode node : nodes) { Dependency dependency = dependencyContainer.getDependencyMap().get(node.getAddress()); if (dependency.getProjectPath() != null) { continue; } switch (node.getNodeType()) { case JAVA: JavaDependency javaDep = (JavaDependency) dependency; outLibraries.add(sJarCache.get(factory.create(javaDep))); // intended fall-through case ANDROID: // dont convert but go recursively for potential java dependencies. cloneJavaLibraries(node.getDependencies(), outLibraries); break; case ATOM: // do nothing break; } } }
private static void recursiveSkip( @NonNull MutableDependencyDataMap mutableDependencyDataMap, @NonNull List<DependencyNode> nodes, @NonNull Map<Object, Dependency> dependencyMap, boolean skipAndroidDependency, boolean skipJavaDependency) { for (DependencyNode node : nodes) { Dependency dep = dependencyMap.get(node.getAddress()); if (skipAndroidDependency) { if (dep instanceof AndroidDependency) { mutableDependencyDataMap.skip(dep); } } if (skipJavaDependency) { if (dep instanceof JavaDependency) { mutableDependencyDataMap.skip(dep); } } recursiveSkip( mutableDependencyDataMap, node.getDependencies(), dependencyMap, skipAndroidDependency, skipJavaDependency); } }
private void render( @NonNull final DependencyNode node, @NonNull Map<Object, Dependency> dependencyMap, boolean lastChild) { renderer.visit(styledTextOutput -> { String name = node.getAddress().toString(); Dependency dependency = dependencyMap.get(name); if (dependency instanceof JavaDependency) { JavaDependency javaDependency = (JavaDependency) dependency; if (javaDependency.isLocal()) { String path = FileUtils.relativePath( javaDependency.getArtifactFile(), project.getProjectDir()); name = path; } } getTextOutput().text(name); }, lastChild); renderChildren(node.getDependencies(), dependencyMap); }
List<DependencyNode> childrenAtoms = atomNode.getDependencies() .stream() .filter(node -> node.getNodeType() == DependencyNode.NodeType.ATOM)